🚀 Grammar-Aware Code Formatter: Structure through separation (supports Go, JavaScript, TypeScript, JSX, and TSX)
go
formatter
code-formatter
javascript
typescript
jsx
tsx
perf(engine): Write formatted output directly into strings.Builder
+38
-20
+35
-19
engine/engine.go
+35
-19
engine/engine.go
···
14
14
CommentMode CommentMode
15
15
}
16
16
17
-
func (e *Engine) Format(events []LineEvent) []string {
18
-
resultLines := make([]string, 0, len(events))
17
+
func (e *Engine) format(events []LineEvent, resultBuilder *strings.Builder) {
18
+
hasWrittenContent := false
19
19
previousWasOpenBrace := false
20
20
previousStatementType := ""
21
21
previousWasComment := false
···
24
24
25
25
for eventIndex, event := range events {
26
26
if event.InRawString {
27
-
resultLines = append(resultLines, event.Content)
27
+
if hasWrittenContent {
28
+
resultBuilder.WriteByte('\n')
29
+
}
30
+
31
+
resultBuilder.WriteString(event.Content)
32
+
33
+
hasWrittenContent = true
28
34
29
35
continue
30
36
}
···
43
49
currentIsTopLevel := event.HasASTInfo && event.IsTopLevel
44
50
currentIsScoped := event.HasASTInfo && event.IsScoped
45
51
46
-
if len(resultLines) > 0 && !previousWasOpenBrace && !event.IsClosingBrace && !event.IsCaseLabel {
52
+
if hasWrittenContent && !previousWasOpenBrace && !event.IsClosingBrace && !event.IsCaseLabel {
47
53
if currentIsTopLevel && previousWasTopLevel && currentStatementType != previousStatementType {
48
54
if !(e.CommentMode == CommentsFollow && previousWasComment) {
49
55
needsBlankLine = true
···
62
68
nextIndex := e.findNextNonComment(events, eventIndex+1)
63
69
64
70
if nextIndex >= 0 {
65
-
next := events[nextIndex]
71
+
nextNonCommentEvent := events[nextIndex]
66
72
67
-
if next.HasASTInfo {
68
-
nextIsTopLevel := next.IsTopLevel
69
-
nextIsScoped := next.IsScoped
73
+
if nextNonCommentEvent.HasASTInfo {
74
+
nextIsTopLevel := nextNonCommentEvent.IsTopLevel
75
+
nextIsScoped := nextNonCommentEvent.IsScoped
70
76
71
-
if nextIsTopLevel && previousWasTopLevel && next.StatementType != previousStatementType {
77
+
if nextIsTopLevel && previousWasTopLevel && nextNonCommentEvent.StatementType != previousStatementType {
72
78
needsBlankLine = true
73
79
} else if nextIsScoped || previousWasScoped {
74
80
needsBlankLine = true
75
-
} else if next.StatementType != "" && previousStatementType != "" && next.StatementType != previousStatementType {
81
+
} else if nextNonCommentEvent.StatementType != "" && previousStatementType != "" && nextNonCommentEvent.StatementType != previousStatementType {
76
82
needsBlankLine = true
77
83
}
78
84
}
···
81
87
}
82
88
83
89
if needsBlankLine {
84
-
resultLines = append(resultLines, "")
90
+
resultBuilder.WriteByte('\n')
85
91
}
86
92
87
-
resultLines = append(resultLines, event.Content)
93
+
if hasWrittenContent {
94
+
resultBuilder.WriteByte('\n')
95
+
}
96
+
97
+
resultBuilder.WriteString(event.Content)
98
+
99
+
hasWrittenContent = true
88
100
previousWasOpenBrace = event.IsOpeningBrace || event.IsCaseLabel
89
101
previousWasComment = event.IsCommentOnly
90
102
···
99
111
}
100
112
}
101
113
102
-
return resultLines
114
+
resultBuilder.WriteByte('\n')
103
115
}
104
116
105
117
func (e *Engine) FormatToString(events []LineEvent) string {
106
-
lines := e.Format(events)
107
-
lines = append(lines, "")
118
+
var resultBuilder strings.Builder
119
+
120
+
resultBuilder.Grow(len(events) * 40)
121
+
e.format(events, &resultBuilder)
108
122
109
-
return strings.Join(lines, "\n")
123
+
return resultBuilder.String()
110
124
}
111
125
112
126
func (e *Engine) FormatToBytes(events []LineEvent) []byte {
113
-
lines := e.Format(events)
114
-
lines = append(lines, "")
127
+
var resultBuilder strings.Builder
128
+
129
+
resultBuilder.Grow(len(events) * 40)
130
+
e.format(events, &resultBuilder)
115
131
116
-
return []byte(strings.Join(lines, "\n"))
132
+
return []byte(resultBuilder.String())
117
133
}
118
134
119
135
func (e *Engine) findNextNonComment(events []LineEvent, startIndex int) int {
+3
-1
engine/engine_test.go
+3
-1
engine/engine_test.go
···
6
6
)
7
7
8
8
func formatResult(formattingEngine *Engine, events []LineEvent) string {
9
-
return strings.Join(formattingEngine.Format(events), "\n")
9
+
result := formattingEngine.FormatToString(events)
10
+
11
+
return strings.TrimSuffix(result, "\n")
10
12
}
11
13
12
14
func TestEngineCollapsesBlanks(t *testing.T) {