Port cadencefmt

formatter/bench_test.go

@@ -0,0 +1,87 @@
+/*
+ * Cadence - The resource-oriented smart contract programming language
+ *
+ * Copyright Flow Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package formatter_test
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/onflow/cadence/formatter"
+)
+
+func loadSnapshotInputs(b *testing.B) map[string][]byte {
+	b.Helper()
+	root := findRepoRoot(b)
+	dir := filepath.Join(root, "testdata", "format")
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		b.Fatalf("reading testdata dir: %v", err)
+	}
+	inputs := make(map[string][]byte, len(entries))
+	for _, e := range entries {
+		if !e.IsDir() {
+			continue
+		}
+		data, err := os.ReadFile(filepath.Join(dir, e.Name(), "input.cdc"))
+		if err != nil {
+			b.Fatalf("reading input %s: %v", e.Name(), err)
+		}
+		inputs[e.Name()] = data
+	}
+	return inputs
+}
+
+// --- End-to-end benchmarks ---
+
+func BenchmarkFormat_Snapshot(b *testing.B) {
+	inputs := loadSnapshotInputs(b)
+	opts := formatter.Default()
+
+	var totalBytes int64
+	for _, data := range inputs {
+		totalBytes += int64(len(data))
+	}
+
+	b.ResetTimer()
+	b.SetBytes(totalBytes)
+	for b.Loop() {
+		for name, data := range inputs {
+			if _, err := formatter.Format(data, name+".cdc", opts); err != nil {
+				b.Fatalf("format %s: %v", name, err)
+			}
+		}
+	}
+}
+
+func BenchmarkFormat_PerCase(b *testing.B) {
+	inputs := loadSnapshotInputs(b)
+	opts := formatter.Default()
+
+	for name, data := range inputs {
+		b.Run(name, func(b *testing.B) {
+			b.SetBytes(int64(len(data)))
+			for b.Loop() {
+				if _, err := formatter.Format(data, name+".cdc", opts); err != nil {
+					b.Fatalf("format: %v", err)
+				}
+			}
+		})
+	}
+}

formatter/formatter.go

@@ -0,0 +1,221 @@
+/*
+ * Cadence - The resource-oriented smart contract programming language
+ *
+ * Copyright Flow Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package formatter
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/turbolent/prettier"
+
+	"github.com/onflow/cadence/ast"
+	"github.com/onflow/cadence/formatter/render"
+	"github.com/onflow/cadence/formatter/rewrite"
+	"github.com/onflow/cadence/formatter/trivia"
+	"github.com/onflow/cadence/formatter/verify"
+	"github.com/onflow/cadence/parser"
+)
+
+// ErrParse marks errors caused by malformed input source.
+// ErrInternal marks errors caused by formatter bugs (rewrite failure,
+// orphaned comments, round-trip verification failure). Callers can
+// distinguish these via errors.Is to choose an appropriate exit code.
+var (
+	ErrParse    = errors.New("parse error")
+	ErrInternal = errors.New("internal error")
+)
+
+// Format parses Cadence source and returns deterministically formatted output.
+// filename is used for diagnostics only; the file need not exist on disk.
+func Format(src []byte, filename string, opts Options) ([]byte, error) {
+	if err := opts.Validate(); err != nil {
+		return nil, err
+	}
+
+	program, err := parser.ParseProgram(nil, src, parser.Config{})
+	if err != nil {
+		return nil, fmt.Errorf("%w: %w", ErrParse, err)
+	}
+
+	// Extract and attach comments
+	comments := trivia.Scan(src)
+	groups := trivia.Group(comments, src)
+	cm := trivia.Attach(program, groups, src)
+
+	// Apply AST rewrites (import sorting, etc.)
+	if err := rewrite.Apply(program, cm, opts.SortImports); err != nil {
+		return nil, fmt.Errorf("%w: rewrite failed: %w", ErrInternal, err)
+	}
+
+	indent := strings.Repeat(opts.IndentCharacter, opts.IndentCount)
+
+	// Render AST with interleaved comments
+	var semicolons map[ast.Element]bool
+	if !opts.StripSemicolons {
+		semicolons = trivia.ScanSemicolons(src, program)
+	}
+	doc := render.Program(program, cm, src, semicolons)
+
+	var buf bytes.Buffer
+	prettier.Prettier(&buf, doc, opts.LineWidth, indent)
+
+	result := collapseBlankLines(
+		rejoinStringInterpolations(stripTrailingLineWhitespace(buf.Bytes())),
+		opts.KeepBlankLines,
+	)
+
+	// Verify no orphaned comments remain
+	if !cm.IsEmpty() {
+		details := cm.OrphanDetails()
+		return result, fmt.Errorf("%w: orphaned comments remain in CommentMap\n%s", ErrInternal, details)
+	}
+
+	// Round-trip verification: re-parse and compare ASTs
+	if !opts.SkipVerify {
+		if err := verify.RoundTrip(src, result); err != nil {
+			return result, fmt.Errorf("%w: round-trip verification failed: %w", ErrInternal, err)
+		}
+	}
+
+	return result, nil
+}
+
+// rejoinStringInterpolations collapses line breaks inside string template
+// interpolations \(...). The prettier library may break expressions inside
+// interpolations across lines; this rejoins them into a single line.
+// Tracks paren depth to find the matching ) for each \(.
+func rejoinStringInterpolations(data []byte) []byte {
+	result := make([]byte, 0, len(data))
+	i := 0
+	inString := false
+
+	for i < len(data) {
+		b := data[i]
+
+		// Track string boundaries (handle escaped quotes)
+		if b == '"' && !inString {
+			inString = true
+			result = append(result, b)
+			i++
+			continue
+		}
+		if b == '"' && inString {
+			inString = false
+			result = append(result, b)
+			i++
+			continue
+		}
+
+		// Handle escape sequences inside strings
+		if inString && b == '\\' && i+1 < len(data) {
+			if data[i+1] == '(' {
+				// Start of interpolation \( — scan to matching )
+				result = append(result, '\\', '(')
+				i += 2
+				depth := 1
+				for i < len(data) && depth > 0 {
+					c := data[i]
+					if c == '(' {
+						depth++
+						result = append(result, c)
+					} else if c == ')' {
+						depth--
+						result = append(result, c)
+					} else if c == '\n' {
+						// Collapse newline + following whitespace. The expression
+						// content already has operators/dots that provide spacing.
+						i++
+						for i < len(data) && (data[i] == ' ' || data[i] == '\t') {
+							i++
+						}
+						// Add a space unless the next char is . (member access)
+						if i < len(data) && data[i] != '.' {
+							result = append(result, ' ')
+						}
+						continue
+					} else if c == '"' {
+						// Nested string inside interpolation — copy until closing "
+						result = append(result, c)
+						i++
+						for i < len(data) && data[i] != '"' {
+							if data[i] == '\\' && i+1 < len(data) {
+								result = append(result, data[i], data[i+1])
+								i += 2
+								continue
+							}
+							result = append(result, data[i])
+							i++
+						}
+						if i < len(data) {
+							result = append(result, data[i]) // closing "
+						}
+					} else {
+						result = append(result, c)
+					}
+					i++
+				}
+				continue
+			}
+			// Other escape: copy both bytes
+			result = append(result, b, data[i+1])
+			i += 2
+			continue
+		}
+
+		result = append(result, b)
+		i++
+	}
+
+	return result
+}
+
+// collapseBlankLines limits consecutive blank lines to at most max.
+func collapseBlankLines(data []byte, max int) []byte {
+	lines := bytes.Split(data, []byte("\n"))
+	result := make([][]byte, 0, len(lines))
+	consecutive := 0
+	for _, line := range lines {
+		if len(bytes.TrimSpace(line)) == 0 {
+			consecutive++
+			if consecutive > max {
+				continue
+			}
+		} else {
+			consecutive = 0
+		}
+		result = append(result, line)
+	}
+	return bytes.Join(result, []byte("\n"))
+}
+
+// stripTrailingLineWhitespace strips indent whitespace from blank lines.
+// The prettier library emits indent prefixes on blank lines inside Indent
+// blocks (e.g. "    \n" instead of "\n"); this cleans that up.
+// Only whitespace-only lines are affected — content lines are not touched.
+func stripTrailingLineWhitespace(data []byte) []byte {
+	lines := bytes.Split(data, []byte("\n"))
+	for i, line := range lines {
+		if len(bytes.TrimRight(line, " \t")) == 0 {
+			lines[i] = nil
+		}
+	}
+	return bytes.Join(lines, []byte("\n"))
+}