Adding `gofmt` library as a dependency

Run this command in a terminal, in your project's directory:

cargo add gofmt

To add it manually, edit your project's Cargo.toml file and add to the [dependencies] section:

gofmt = "0.1.0"

The gofmt library will be automatically available globally. Read the gofmt library documentation.

Back to the crate overview.

Readme

gofmt.rs

A Rust implementation of Go language formatting, providing fast and accurate Go source code parsing and formatting capabilities.

Features

Complete Go Parser: Full implementation of Go language parsing with proper AST generation
Accurate Formatting: Produces output identical to the official gofmt tool
High Performance: Optimized Rust implementation with benchmarking capabilities
Comprehensive Testing: Extensive test suite with golden files covering all Go language constructs
Tab-based Formatting: Proper alignment and indentation using tabs and spaces
Comment Preservation: Maintains and properly formats all types of Go comments

Installation

Add this to your Cargo.toml:

[dependencies]
gofmt = "0.1.0"

Usage

Basic Formatting

use gofmt::formatter::format;

fn main() -> Result<(), String> {
    let go_source = r#"
package main

func main(){
fmt.Println("Hello, World!")
}
"#;

    let formatted = format(go_source)?;
    let result = String::from_utf8(formatted).unwrap();
    println!("{}", result);
    Ok(())
}

Library Structure

The library is organized into several key modules:

formatter: Main formatting logic and public API
parser: Go language parser implementation
ast: Abstract Syntax Tree definitions for Go constructs
scanner: Lexical analysis and tokenization
source: Source code management and line tracking
tabwriter: Tab-based formatting and alignment
tokens: Token definitions and precedence rules

Testing

Run the test suite:

cargo test

Run benchmarks:

cargo bench

Test Data

The project includes an extensive test suite with over 200 test cases covering:

Basic Go constructs: functions, variables, types, interfaces
Complex formatting: composite literals, function calls, expressions
Comment handling: line comments, block comments, documentation
Go build directives: build tags and compiler directives
Advanced features: generics, type parameters, complex expressions
gofumpt compatibility: Additional formatting rules from gofumpt

Each test case consists of:

.input file: Unformatted Go source code
.golden file: Expected formatted output

Performance

The formatter is designed for high performance and includes benchmark tests. Run benchmarks to see performance characteristics:

cargo bench

Project Structure

src/
├── lib.rs          # Library entry point
├── formatter.rs    # Main formatting logic
├── parser.rs       # Go language parser
├── ast.rs          # AST node definitions
├── scanner.rs      # Lexical analyzer
├── source.rs       # Source management
├── tabwriter.rs    # Tab formatting
└── tokens.rs       # Token definitions

tests_data/         # Test cases with input/golden files
benches/           # Performance benchmarks

Contributing

Contributions are welcome! This project aims to maintain 100% compatibility with the official Go formatter. When adding features or fixing bugs:

Ensure all existing tests pass
Add test cases for new functionality
Follow Rust best practices and the existing code style
Run benchmarks to ensure no performance regressions

Dependencies

strum: Enum utilities
unic-ucd-category: Unicode character categories
anyhow: Error handling
thiserror: Error derivation
unicode-width: Text width calculations
libm: Math functions
criterion: Benchmarking (dev dependency)

License

This project follows the same principles as the original Go formatter, focusing on consistent and deterministic code formatting.

Adding gofmt library as a dependency

Adding `gofmt` library as a dependency