jennifer

Jennifer provides a fluent API where methods return the receiver (Statement or Group) to enable natural method chaining that mirrors Go syntax structure. This approach eliminates string concatenation and templating by composing immutable code elements through a chain of method calls like f.Func().Id("main").Params().Block(...), where each method adds tokens to an internal sequence and returns self for continued chaining.

Jennifer automatically tracks package imports when Qual() is used to reference qualified identifiers (e.g., Qual("fmt", "Println")). The File type maintains an import registry that deduplicates imports, detects naming conflicts, applies aliases when needed, and only renders imports that are actually used in the generated code. This eliminates manual import management and prevents unused import errors.

Jennifer provides Comment() method for generating single-line comments and Comment() with multi-line support for block comments. Comments are rendered with proper // or /* */ syntax and indentation matching surrounding code. Documentation comments (starting with //) are automatically formatted to match Go conventions, enabling generation of documented code with proper comment placement.

Jennifer provides Id() for local identifiers, Qual() for qualified package references, and Dot() for member access. Id() generates simple identifiers like variable or function names, Qual(importPath, identifier) generates qualified references that trigger automatic import management, and Dot() chains member access like obj.Field. These methods form the foundation for building expressions that reference external packages, local variables, and nested members with automatic import tracking.

Jennifer provides Lit() for generic literals, LitRune() for rune literals, LitByte() for byte literals, and LitString() for string literals with proper escaping. Each method handles type-specific formatting: Lit() uses Go's %#v format for automatic type inference, LitRune() wraps values in single quotes, LitByte() produces byte literals, and LitString() handles escape sequences. These methods ensure literals are rendered with correct Go syntax and proper type representation.

Jennifer provides Op() method for generating operators in expressions, enabling construction of arithmetic, logical, comparison, and assignment operators. Op() takes an operator string and appends it to the Statement token sequence, allowing chaining with operands to build complete expressions. This enables programmatic construction of expressions like a + b, x == y, or ptr->field with proper operator syntax.

Jennifer provides Call() method for generating function calls with arguments. Call() creates a Call group that renders with parentheses and comma-separated arguments, enabling construction of expressions like fmt.Println("hello") or obj.Method(arg1, arg2). Arguments are specified through method chaining on the Call group, and the entire call expression can be chained with other methods to build complex call chains.

Jennifer's Code interface exposes a render(io.Writer, *File) method that enables custom formatting and rendering logic. Developers can implement custom Code types with specialized render() implementations to produce non-standard formatting, conditional rendering based on File context, or integration with external formatting tools. The File parameter provides access to import registry and formatting state, enabling context-aware rendering decisions.

Jennifer defines a Code interface that all code elements (Statement, Group, literals, identifiers) must implement with render(io.Writer, *File) methods. This interface-based architecture enables composable code construction where any Code-implementing type can be nested within another, providing compile-time type safety and ensuring all elements can be rendered correctly. The File parameter in render() provides context for import resolution and formatting decisions.

Statement is the primary building block in Jennifer, internally maintaining a sequence of tokens that represent Go code. Statements provide methods for adding identifiers (Id(), Qual(), Dot()), literals (Lit(), LitRune(), LitByte()), operators (Op()), and control structures (If(), For(), Switch(), Return()). Each method appends tokens to the sequence and returns the Statement for chaining, enabling progressive construction of complex expressions and statements.

Group is a container for organizing collections of code elements with different rendering semantics depending on context. Jennifer provides specialized group types: Block (renders with braces and newlines for function bodies), Values (renders with braces and commas for slice/struct literals), Call (renders with parentheses and commas for function calls), Params (renders with parentheses and commas for function parameters), and Index (renders with brackets and colons for array indexing). Each group type automatically applies appropriate separators and delimiters based on its semantic purpose.

File represents a complete Go source file and manages package declarations, import statements, and top-level code elements. File tracks all Qual() references through its internal import registry, renders the package declaration, generates the import block with automatic deduplication and alias resolution, and then renders all code elements in order. The File type provides methods to add functions, types, variables, and constants, and can render to an io.Writer or return a formatted string.

Jennifer provides methods to generate function and method declarations with full support for receivers, parameters, return types, and function bodies. The Func() method creates a function declaration, Receiver() adds a receiver for methods, Params() defines parameters with types, Returns() specifies return types, and Block() contains the function body. Each method returns the Statement for chaining, enabling natural construction of function signatures followed by bodies.

Jennifer provides methods to generate control flow structures: If() for conditional blocks, For() for loops, Switch() for switch statements, and Return() for return statements. Each method creates a Statement that can be chained with conditions, loop ranges, switch cases, and return values. Control flow structures can contain nested Blocks or other statements, enabling complex nested control flow generation with proper indentation and formatting.

Jennifer enables generation of struct and interface type declarations through Type() method combined with Struct() or Interface() for the type body. Struct fields are added with Field() specifying name, type, and optional tags, while interface methods are added with Method() specifying signature. The library automatically handles field alignment, tag formatting, and method signature rendering, producing properly formatted type declarations.

Jennifer provides Map() and Index() methods for generating map and slice literals with proper syntax. Map() creates a map literal with key-value pairs specified through method chaining, while Index() creates array/slice indexing expressions. The Values() group type renders collections with comma separators and braces, automatically handling multi-line formatting for readability. Literal values are specified using Lit() for constants or expressions for computed values.