reorder struct fields to reduce memory/add speed

This runs Go's "fieldalignment" pass and fixes all reports.

Author: evanw

cmd/esbuild/service.go

@@ -31,21 +31,21 @@ type serveStopCallback func()
 type pluginResolveCallback func(uint32, map[string]interface{}) []byte
 
 type activeBuild struct {
-	mutex         sync.Mutex
-	refCount      int
 	rebuild       rebuildCallback
 	watchStop     watchStopCallback
 	serveStop     serveStopCallback
 	pluginResolve pluginResolveCallback
+	mutex         sync.Mutex
+	refCount      int
 }
 
 type serviceType struct {
-	mutex              sync.Mutex
 	callbacks          map[uint32]responseCallback
 	activeBuilds       map[int]*activeBuild
-	nextRequestID      uint32
 	outgoingPackets    chan outgoingPacket
 	keepAliveWaitGroup sync.WaitGroup
+	mutex              sync.Mutex
+	nextRequestID      uint32
 }
 
 func (service *serviceType) getActiveBuild(key int) *activeBuild {

cmd/esbuild/stdio_protocol.go

@@ -34,9 +34,9 @@ func readLengthPrefixedSlice(bytes []byte) (slice []byte, leftOver []byte, ok bo
 }
 
 type packet struct {
+	value     interface{}
 	id        uint32
 	isRequest bool
-	value     interface{}
 }
 
 func encodePacket(p packet) []byte {

internal/ast/ast.go

@@ -117,16 +117,16 @@ func (flags ImportRecordFlags) Has(flag ImportRecordFlags) bool {
 }
 
 type ImportRecord struct {
-	Range      logger.Range
-	Path       logger.Path
 	Assertions *[]AssertEntry
+	Path       logger.Path
+	Range      logger.Range
 
 	// The resolved source index for an internal import (within the bundle) or
 	// nil for an external import (not included in the bundle)
 	SourceIndex Index32
 
-	Kind  ImportKind
 	Flags ImportRecordFlags
+	Kind  ImportKind
 }
 
 type AssertEntry struct {

internal/bundler/bundler.go

@@ -35,13 +35,13 @@ import (
 )
 
 type scannerFile struct {
-	inputFile  graph.InputFile
-	pluginData interface{}
-
 	// If "AbsMetadataFile" is present, this will be filled out with information
 	// about this file in JSON format. This is a partial JSON file that will be
 	// fully assembled later.
 	jsonMetadataChunk string
+
+	pluginData interface{}
+	inputFile  graph.InputFile
 }
 
 // This is data related to source maps. It's computed in parallel with linking
@@ -60,40 +60,40 @@ type dataForSourceMap struct {
 }
 
 type Bundle struct {
-	fs          fs.FS
-	res         resolver.Resolver
-	files       []scannerFile
-	entryPoints []graph.EntryPoint
-
 	// The unique key prefix is a random string that is unique to every bundling
 	// operation. It is used as a prefix for the unique keys assigned to every
 	// chunk during linking. These unique keys are used to identify each chunk
 	// before the final output paths have been computed.
 	uniqueKeyPrefix string
+
+	fs          fs.FS
+	res         resolver.Resolver
+	files       []scannerFile
+	entryPoints []graph.EntryPoint
 }
 
 type parseArgs struct {
 	fs              fs.FS
 	log             logger.Log
 	res             resolver.Resolver
 	caches          *cache.CacheSet
-	keyPath         logger.Path
 	prettyPath      string
-	sourceIndex     uint32
 	importSource    *logger.Source
 	sideEffects     graph.SideEffects
-	importPathRange logger.Range
 	pluginData      interface{}
-	options         config.Options
 	results         chan parseResult
 	inject          chan config.InjectedFile
-	skipResolve     bool
 	uniqueKeyPrefix string
+	keyPath         logger.Path
+	options         config.Options
+	importPathRange logger.Range
+	sourceIndex     uint32
+	skipResolve     bool
 }
 
 type parseResult struct {
-	file           scannerFile
 	resolveResults []*resolver.ResolveResult
+	file           scannerFile
 	tlaCheck       tlaCheck
 	ok             bool
 }
@@ -810,10 +810,10 @@ func RunOnResolvePlugins(
 }
 
 type loaderPluginResult struct {
-	loader        config.Loader
+	pluginData    interface{}
 	absResolveDir string
 	pluginName    string
-	pluginData    interface{}
+	loader        config.Loader
 }
 
 func runOnLoadPlugins(
@@ -982,17 +982,20 @@ type scanner struct {
 	fs              fs.FS
 	res             resolver.Resolver
 	caches          *cache.CacheSet
-	options         config.Options
 	timer           *helpers.Timer
 	uniqueKeyPrefix string
 
-	// This is not guarded by a mutex because it's only ever modified by a single
+	// These are not guarded by a mutex because it's only ever modified by a single
 	// thread. Note that not all results in the "results" array are necessarily
 	// valid. Make sure to check the "ok" flag before using them.
 	results       []parseResult
 	visited       map[logger.Path]uint32
 	resultChannel chan parseResult
-	remaining     int
+
+	options config.Options
+
+	// Also not guarded by a mutex for the same reason
+	remaining int
 }
 
 type EntryPoint struct {
@@ -2328,8 +2331,8 @@ type runtimeCacheKey struct {
 }
 
 type runtimeCache struct {
-	astMutex sync.Mutex
 	astMap   map[runtimeCacheKey]js_ast.AST
+	astMutex sync.Mutex
 }
 
 var globalRuntimeCache runtimeCache

internal/bundler/bundler_test.go

@@ -59,11 +59,11 @@ type bundled struct {
 }
 
 type suite struct {
+	expectedSnapshots  map[string]string
+	generatedSnapshots map[string]string
 	name               string
 	path               string
 	mutex              sync.Mutex
-	expectedSnapshots  map[string]string
-	generatedSnapshots map[string]string
 }
 
 func (s *suite) expectBundled(t *testing.T, args bundled) {

internal/bundler/linker.go

@@ -41,13 +41,6 @@ type linkerContext struct {
 	// This helps avoid an infinite loop when matching imports to exports
 	cycleDetector []importTracker
 
-	// We may need to refer to the CommonJS "module" symbol for exports
-	unboundModuleRef js_ast.Ref
-
-	// We may need to refer to the "__esm" and/or "__commonJS" runtime symbols
-	cjsRuntimeRef js_ast.Ref
-	esmRuntimeRef js_ast.Ref
-
 	// This represents the parallel computation of source map related data.
 	// Calling this will block until the computation is done. The resulting value
 	// is shared between threads and must be treated as immutable.
@@ -56,6 +49,13 @@ type linkerContext struct {
 	// This is passed to us from the bundling phase
 	uniqueKeyPrefix      string
 	uniqueKeyPrefixBytes []byte // This is just "uniqueKeyPrefix" in byte form
+
+	// We may need to refer to the CommonJS "module" symbol for exports
+	unboundModuleRef js_ast.Ref
+
+	// We may need to refer to the "__esm" and/or "__commonJS" runtime symbols
+	cjsRuntimeRef js_ast.Ref
+	esmRuntimeRef js_ast.Ref
 }
 
 type partRange struct {
@@ -72,11 +72,6 @@ type chunkInfo struct {
 	filesWithPartsInChunk map[uint32]bool
 	entryBits             helpers.BitSet
 
-	// This information is only useful if "isEntryPoint" is true
-	isEntryPoint  bool
-	sourceIndex   uint32 // An index into "c.sources"
-	entryPointBit uint   // An index into "c.graph.EntryPoints"
-
 	// For code splitting
 	crossChunkImports []chunkImport
 
@@ -94,11 +89,6 @@ type chunkInfo struct {
 	// If non-empty, this chunk needs to generate an external legal comments file.
 	externalLegalComments []byte
 
-	// When this chunk is initially generated in isolation, the output pieces
-	// will contain slices of the output with the unique keys of other chunks
-	// omitted.
-	intermediateOutput intermediateOutput
-
 	// This contains the hash for just this chunk without including information
 	// from the hashes of other chunks. Later on in the linking process, the
 	// final hash for this chunk will be constructed by merging the isolated
@@ -109,7 +99,18 @@ type chunkInfo struct {
 	// Other fields relating to the output file for this chunk
 	jsonMetadataChunkCallback func(finalOutputSize int) helpers.Joiner
 	outputSourceMap           sourcemap.SourceMapPieces
-	isExecutable              bool
+
+	// When this chunk is initially generated in isolation, the output pieces
+	// will contain slices of the output with the unique keys of other chunks
+	// omitted.
+	intermediateOutput intermediateOutput
+
+	// This information is only useful if "isEntryPoint" is true
+	entryPointBit uint   // An index into "c.graph.EntryPoints"
+	sourceIndex   uint32 // An index into "c.sources"
+	isEntryPoint  bool
+
+	isExecutable bool
 }
 
 type chunkImport struct {
@@ -141,15 +142,15 @@ type outputPiece struct {
 }
 
 type intermediateOutput struct {
+	// If the chunk has references to other chunks, then "pieces" contains the
+	// contents of the chunk and "joiner" should not be used. Another joiner
+	// will have to be constructed later when merging the pieces together.
+	pieces []outputPiece
+
 	// If the chunk doesn't have any references to other chunks, then "pieces" is
 	// nil and "joiner" contains the contents of the chunk. This is more efficient
 	// because it avoids doing a join operation twice.
 	joiner helpers.Joiner
-
-	// Otherwise, "pieces" contains the contents of the chunk and "joiner" should
-	// not be used. Another joiner will have to be constructed later when merging
-	// the pieces together.
-	pieces []outputPiece
 }
 
 type chunkRepr interface{ isChunk() }
@@ -162,10 +163,10 @@ type chunkReprJS struct {
 	partsInChunkInOrder []partRange
 
 	// For code splitting
-	crossChunkPrefixStmts  []js_ast.Stmt
-	crossChunkSuffixStmts  []js_ast.Stmt
 	exportsToOtherChunks   map[js_ast.Ref]string
 	importsFromOtherChunks map[uint32]crossChunkImportItemArray
+	crossChunkPrefixStmts  []js_ast.Stmt
+	crossChunkSuffixStmts  []js_ast.Stmt
 }
 
 type chunkReprCSS struct {
@@ -994,8 +995,8 @@ func (c *linkerContext) computeCrossChunkDependencies(chunks []chunkInfo) {
 }
 
 type crossChunkImport struct {
-	chunkIndex        uint32
 	sortedImportItems crossChunkImportItemArray
+	chunkIndex        uint32
 }
 
 // This type is just so we can use Go's native sort function
@@ -1031,8 +1032,8 @@ func (c *linkerContext) sortedCrossChunkImports(chunks []chunkInfo, importsFromO
 }
 
 type crossChunkImportItem struct {
-	ref         js_ast.Ref
 	exportAlias string
+	ref         js_ast.Ref
 }
 
 // This type is just so we can use Go's native sort function
@@ -2128,9 +2129,9 @@ const (
 )
 
 type matchImportResult struct {
+	alias            string
 	kind             matchImportKind
 	namespaceRef     js_ast.Ref
-	alias            string
 	sourceIndex      uint32
 	nameLoc          logger.Loc // Optional, goes with sourceIndex, ignore if zero
 	otherSourceIndex uint32
@@ -2859,8 +2860,8 @@ func (c *linkerContext) findImportedCSSFilesInJSOrder(entryPoint uint32) (order
 // traversal order is B D C A.
 func (c *linkerContext) findImportedFilesInCSSOrder(entryPoints []uint32) (externalOrder []externalImportCSS, internalOrder []uint32) {
 	type externalImportsCSS struct {
-		unconditional bool
 		conditions    [][]css_ast.Token
+		unconditional bool
 	}
 
 	visited := make(map[uint32]bool)
@@ -4893,13 +4894,12 @@ func (c *linkerContext) generateGlobalNamePrefix() string {
 type compileResultCSS struct {
 	css_printer.PrintResult
 
-	sourceIndex uint32
-
 	// This is the line and column offset since the previous CSS string
 	// or the start of the file if this is the first CSS string.
 	generatedOffset sourcemap.LineColumnOffset
 
-	hasCharset bool
+	sourceIndex uint32
+	hasCharset  bool
 }
 
 func (c *linkerContext) generateChunkCSS(chunks []chunkInfo, chunkIndex int, chunkWaitGroup *sync.WaitGroup) {

internal/cache/cache.go

@@ -32,11 +32,11 @@ import (
 //   reused even if the contents of that "package.json" file have changed.
 //
 type CacheSet struct {
-	SourceIndexCache SourceIndexCache
 	FSCache          FSCache
 	CSSCache         CSSCache
 	JSONCache        JSONCache
 	JSCache          JSCache
+	SourceIndexCache SourceIndexCache
 }
 
 func MakeCacheSet() *CacheSet {
@@ -61,8 +61,8 @@ func MakeCacheSet() *CacheSet {
 }
 
 type SourceIndexCache struct {
-	mutex           sync.Mutex
 	entries         map[sourceIndexKey]uint32
+	mutex           sync.Mutex
 	nextSourceIndex uint32
 }