Compiler frontend

Part I · 81 threads in 5 era slices, from Go 1.0 to Go 1.28. Each thread gives its design, then a per-release timeline of what landed (Done) and what was still open. Release labels in a timeline link to that release's page.

● = the thread had substantive commits in that cycle; hover for the stage summary, click to jump to it in the release page.

Thread map, Go 1.0 – 1.17

Thread map, Go 1.18 – 1.28

Compiler frontend (Go 1.0: 2008–2012)

Reader: Claude Sonnet. Cites 863 of 935 commits in this slice; every non-noise commit is cited, plus 29 larger commits the noise filter had set aside, which a separate gap reader described. Most pre-2010 messages are one line long, so many claims rest on subject lines and diffstats. About 400 small fixes are cited as per-year hash lists.

Lexer, grammar and statement syntax (semicolons, chan operators, conversions)

Span: Go 1.0 → Go 1.0 · Status at go1.17: the surface syntax is the Go 1 one; the yacc grammar go.y and hand-written lexer lex.c stayed the parser until the compiler was rewritten in Go (not in this range). → continues as The syntax package (parser, scanner, tree) (1.18+)

Continues in: Parser: from yacc to a hand-written recursive-descent parser (Go 1.1 → Go 1.8)

Design. The frontend is src/cmd/gc in C: a bison/yacc grammar go.y that builds Node trees directly, a lexer lex.c, and per-architecture code generators (6g/8g/5g) that initially owned most of the semantic code. In 2008 almost every syntactic rule of the language was still moving, and the compiler followed the spec as it was rewritten week by week. Statement termination is the clearest example. The first optional-semicolon support (8200a0b088, 0006c83231, c242b53d22) was replaced by “all statements and declarations are terminated by semicolons; they may be omitted at top level and before/after a closing ) or }” (d364d28142), which doubled parts of the grammar; in June 2009 the rule was moved into the lexer, which now inserts the semicolon itself so the type and statement grammars no longer needed duplicated variants (8abcdee175, 179 insertions, 284 deletions). Follow-ups made 6g match the spec exactly: no semicolon after the package clause, one allowed after imports (aaaa1fc69b), a semicolon inserted at EOF (ec13ed1fce), and mandatory { } around else blocks (58e19aa4cb, 2011). The if condition became mandatory (52943bfe4d, 2011).

Expression and type syntax went through several iterations. Conversions and constructors were first T{} and T(expr) (0194aaf918, Ken Thompson, which also stopped treating func as a type), then composite literals briefly became T(...) with a warning for the brace form (07244f7c80, Feb 2009), and returned to T{x} with a stricter split between T(x) conversion and x.(T) assertion a month later (49cc649e59). Parentheses were allowed to disambiguate types (ebc10db3e1). Channels first had a <-/-< pair, then a new syntax (ac048ce7f4) and in September 2008 binary <- is send and unary <- is receive, with case a := <-ch: and case a = <-ch: in select (47919799b4, 304440356d). Directional channel types were enforced in May 2009 (f4d3d22a94) and chan <- chan precedence and func() func() were fixed in 2010 (7abb4b3a96), plus send precedence (0e47460915). In December 2008 *chan became chan and *map became map, with new(T) taking the pointee type: “mainly a syntactic change: the compiler representations don’t change (chan and map are now hidden pointers like string)” (dc7b2e98d2, 88b5c5f0f8, 316d377ac2). The range statement arrived in December 2008 (26b357ca5b, b79272d9a2, ae5a475e20), &^ and &^= in March 2009 (bb02e481d2), [...] closed arrays in January 2009 (b0f627a6e1), and empty var ( ) factoring in October 2008 (5f1202428b). Redundant iota rules were redone twice (d915b96100, c597845e13).

The lexer also gained several user-visible rules: control characters other than white space are rejected (2538cf747b), · is disallowed in source (9e497c3656), backslash-newline in strings is illegal (0c222d6e49), //line file:number directives were added in July 2010 (444066e56d, 19d7fc4026, with the earlier //line number file form changed), and colons were permitted in the directive file name (ecda0fa5d4).

Timeline.

• Go 1.0 — Done: user-visible everything above, in chronological order.
  • 2008: optional semicolons (8200a0b088), a,b := fun() (81b325db1b), new chan syntax (ac048ce7f4), send/receive operators (47919799b4), semicolon rules (d364d28142), *T as implicit declaration of T removed (02d184b303), trailing comma in braced lists (82e41cc533), DOTDOTDOT (74427c6346), range (26b357ca5b), chan/map no longer pointers (dc7b2e98d2), T{} / T(x) (0194aaf918).
  • 2009: composite-literal paren syntax and back (07244f7c80, 49cc649e59), type switches with case nil (a4a10ed856, 0f469a99a3), lexer-driven semicolons (8abcdee175), conversion rules per the new spec (7f3eb2738f), no parens around type in struct literal (9c3c140984), semicolon/package-clause rules (aaaa1fc69b), x[y:] for strings (aa4c638b7b).
  • 2010: //line directives (444066e56d), EOF semicolon (ec13ed1fce), select case expr = <-c (9b62461a8f), new slice spec (fce222a95b), improved syntax errors (2a01d72878, 78c27ed650).
  • 2011: if needs a condition (52943bfe4d), else needs braces (58e19aa4cb), non-blocking send/receive statement syntax removed (cb584707af), x, ok := <-c replaces closed(c) (8bf34e3356).
  • 2012: switch _ := v.(type) rejected (74ee51ee92), diagnose (x) := 0 and similar (112267d55e, 2011), top-level var/const rules (4bcc9c6b5e). Left open: nothing noted in the commits; the C yacc grammar is still the parser at the go1 tag.

Package system, visibility and import resolution

Span: Go 1.0 → Go 1.0 · Status at go1.17: capitalisation-based export and -p/-D/-I import resolution as of go1; compiler flags later reworked by the build system. → continues as Package paths, -p, and build-system contract (1.18+)

Design. Visibility changed repeatedly in 2008–2009. First came export adjectives on external var, const, type and func declarations (989676d2ba, 695f83a9e0, b59b551be7), and in November 2008 a package keyword for package-local declarations (d3f6093931, 9c7b064043). In January 2009 the export name-list statement was removed and “package local” became the default; the compiler warned when the name’s case did not match the keyword (07d344e442, 3decb42e6f, 605d0746c5). Case then became the real rule: other packages’ lower-case names are rejected in struct field selectors, method calls and P.t (06869eedf9, aec4d3194a, 61590c4c44), assignments to private fields during initialization (9da6666a8a), implicit assignment to non-exported fields in copy and append (151b2f1509) and then the opposite relaxation for method receivers and copy of structs with unexported fields (0b209b36b6, d03611f628).

Package lookup went from a flat global namespace to explicit paths. 6g autoloaded imports via #pragma lib (e90ae879d6, 12c81a0ce8, f95da9a639), later by searching a pkg directory, .6 before .a, archives with __.PKGDEF and 0-length __.SYMDEF (63a84348cc). -I DIR added include directories (062d6998ab), local-path lookup was separated from standard directories (70e232e668), the package global name space was eliminated (531e6b77c8, Jan 2010) and the runtime type data records full package paths (1cecac8134). The name main stopped being reserved (c1a695c160, daffc2d2ef). Unused imports are an error (73e52ae971) and print the path (f1550482fa). Import cycles: -p tells the compiler “if you see an import of this package, give up early”, because a cycle otherwise shows up as two different copies of the same package and type-signature mismatches (1e480cd1ad). Import-path hygiene landed in early 2012: \ diagnosed (33f3afa7af), special characters rejected (dc38756ce1), absolute paths disallowed (d0d251f858), ~ allowed on Windows and slash handling (d0a4c9bb62, 29199aa4e4). Relative imports were reworked for cmd/go with a -D prefix option: import "./foo" with -D a/b/c becomes a/b/c/foo, so a _/home/gopher/foo pseudo-hierarchy makes relative imports ordinary paths (604f375110).

Timeline.

• Go 1.0 — Done: user-visible
  • 2008: export adjectives (989676d2ba, 695f83a9e0), package locals (d3f6093931), autolib (e90ae879d6).
  • 2009: case-based visibility and the removal of export lists (07d344e442, 06869eedf9, 61590c4c44), -I (062d6998ab), whole-package compilation (66bb399fdd, see the typecheck thread), unused imports (73e52ae971), import . fixes (63aeaa2a03, 5a5799f613, 7b240e8135).
  • 2010: global name space dropped (531e6b77c8), full paths in type data (1cecac8134), -u requires imports marked safe (d20ad1c75a), canonical path checks (555f5b6b24, 7e92e1cbfa).
  • 2011: main not reserved (c1a695c160), -p import-cycle flag (1e480cd1ad), package paths in symbol names with period/0x7f escaping (33f1d47b38).
  • 2012: import path validation (dc38756ce1, d0d251f858, daacba5184, cc99d8ad0b), -D for relative imports (604f375110). Left open: nothing noted.

Export/import data format

Span: Go 1.0 → Go 1.0 · Status at go1.17: textual export data in the object file’s __.PKGDEF section was still the format at go1 and in 1.17 had moved through the binary format and then indexed export data → continues as Unified IR: one serialization for noding, stenciling, inlining and export (1.18+)

Continues in: Binary export data and the object-file split (Go 1.1 → Go 1.9)

Design. The compiler writes a text description of everything a package exports into the object file, delimited by $$ markers, and the importing compiler parses it with a second yacc entry in go.y (the “import grammar”). The first version dated June 2008 (2254a8ee99, 343f5aa7b4, 4528854308 made names unique). On 2008-10-03 Russ Cox rewrote it (b8babed7c2, 1827-line delta, export.c shrank by roughly 700 lines): declarations are printed as Go-like type flag.Value interface {...} with fully qualified identifiers, the delimiter changed from (( )) to $$, and sys.go uses a leading export. Other early decisions: only explicitly exported types are exposed to the importer (fb2c66710c), type names “live at the name” so type T struct{ next *T } and type T *struct{ next T } work without forward declarations (74e2e087e2), \n$$ as the section delimiter (4958d41d3b), tag strings on struct fields and across multiple names (f27aaf4819, 1850b29da6, f2b1536328), ... (2fef4c7198), embedded types (21617250f4), and a separate section for non-exported types referenced by exported ones (aacfbb461b). Constants are exact: negative constants (c3d841f5d4), large constants (2b75556436) and multi-precision floats via a decimal-integer “p” exponent syntax (f8797daa9f); complex constants (713e3e1541).

From 2011 the format was prepared for inlining: all transitive dependencies are listed, with indirect imports marked, “purely informational” (e6f3aa6c36); string literals used as package qualifiers are prefixed with @ which removed the : before tags (b536adbfba, Luuk van Dijk); further changes, with a “minimal change to gcimporter” (40b2fe004f); tags allowed on parameters (56668283f1); nil literals exported without inferred type (feaa9ed10a), implicit type bug fixes (5c52404aca, 419c53af30, 77aaa3555d), field names in struct literals inside exported inline bodies not qualified for embedded builtin types (6ff01f01f4), and a limit on the size of exported recursive interfaces to stop memory blowup (aa63a928ea). The byte/uint8 distinction was preserved in errors and import data (862179b0f5).

Timeline.

• Go 1.0 — Done:
  • 2008: first import/export (2254a8ee99), new format (b8babed7c2), embedded type export (21617250f4), mp float constants (f8797daa9f).
  • 2009: re-export of bools fixed (dec12d3654), unsafe import foundation (1d4daa2d39), import-name resolution fixes (c715b58dad, e733766dda).
  • 2010: complex constants (713e3e1541), export of complex types (cd016d7558), full paths (1cecac8134).
  • 2011: metadata for all dependencies (e6f3aa6c36), inlining-preparation format changes (b536adbfba, 40b2fe004f), byte/rune distinction (862179b0f5).
  • 2012: limits and fixes (aa63a928ea, feaa9ed10a, 5c52404aca). Left open: the textual format has to carry inline bodies, which the 2011 commits say they were preparing; no binary format yet.

Constants and multi-precision arithmetic

Span: Go 1.0 → Go 1.0 · Status at go1.17: arbitrary-precision constants as at go1 (mparith); later moved to go/constant and math/big → continues as Language features as seen by the type checker (by release) (1.18+)

Continues in: Constant arithmetic, Mpint/Mpflt and floating-point constants (Go 1.1 → Go 1.9)

Design. Go’s “ideal” constants were implemented by hand in mparith*.c: Mpint integer arithmetic (mp constants 9c2ade358d, fixed arithmetic 272ae659db) and multiprecision floating point Mpflt (3fa4610601, Ken Thompson, December 2008). Floats are truncated when used in float64/float32 contexts (89996e1fb1). Precision work: 29 more bits of precision (Mpscale) from floating-constant multiply with rounding code for const fix = float (95b93c28e3), and floating literal normalisation moved from word-oriented to bit-oriented for up to a full extra word of precision (f6b93ab432); denormals round correctly (cf63e34b1d); constant divide bug (ce85868a00); float zero 0p+0 (f51ca384eb). The type-rule side: ideal bools (a95ee61aea), comparisons have type bool (ed6de5af4c) and, at the end, “drop ideal bool” (126d475a43) followed by “new, less strict bool rules” (e29d3dfc49) and the return of ideal bool for a corner case (a457fa500d). Complex numbers arrived in February 2010 as a three-step plan (front-end, back-end, library): complex, complex64, complex128 types (33d6a260c1), complex constant multiply and divide (fc010adcd7), simplified typecheck that does not convert to float prematurely (4ac011a011), and constant float parts of complex constants (94df1a067c).

Shift rules changed many times: typing of (1<<x) (944ad62ecd), x << "a" and 1 << int(2) (0aa1b1508a), shifts must be unsigned (message, 67941bf644), then “new shift rules” where 1.0<<2 is okay (5ab096d030) and a shift-type bug (4389192669). Unary ^: ^ type(const) inverts “enough” bits, signed becomes illegal (b8be809c10). Constant-evaluation hygiene: constant evaluation decided by whitelist instead of blacklist (1ee83f851d), string constant comparison made unsigned (3a2d64789b), “do not constant-evaluate (interface{})("bar")” (4b13d1b9b5), original expression kept for error messages (4349effb15, 60e4a61d30, 21f1769519), constant shift overflow errors (79db6ada48), friendlier constant arithmetic errors (337547d1c9) and constant % on floats (83feedf7bf). Character constants received typing rules in December 2011 (be0ffbfd02).

Timeline.

• Go 1.0 — Done:
  • 2008: mp ints (9c2ade358d, 272ae659db), exact large-constant export (2b75556436), mp floats (3fa4610601), (1<<x) (944ad62ecd).
  • 2009: ideal bools (a95ee61aea), ^ on consts (b8be809c10), shift checks (0aa1b1508a), float/int64 conversions (1620023d03).
  • 2010: complex (33d6a260c1, fc010adcd7), precision (95b93c28e3, f6b93ab432), const simplifications (ed13d39972).
  • 2011: denormal rounding (cf63e34b1d), shift rules (5ab096d030), character constants (be0ffbfd02, Dec).
  • 2012: ideal bool dropped and relaxed (126d475a43, e29d3dfc49), shift overflow (79db6ada48), len(array)/cap(array) constant rule (d4fb568e04). Left open: nothing noted.

Typecheck/walk separation and package-level declaration order

Span: Go 1.0 → Go 1.0 · Status at go1.17: typecheck pass (typecheck.c) as one separate pass over a whole function tree, still the design at go1.17 in Go form → continues as Old typechecker and IR node-model cleanup (1.18+)

Continues in: The legacy typechecker: error quality, alias/recursive-type handling and type checking order (Go 1.10 → Go 1.17)

Design. Until mid-2009 type checking was intermixed with code generation: walk.c and the arch-specific code did conversions, argument checks and constant evaluation. On 2009-07-29 typecheck was introduced “before walkexpr”, not complete but the compiler still worked (9271c6402e, plus walkexpr taking Node** and dropping indir, 056940d84b; dead code deleted b754b4348f). By 2009-08-03 “typecheck.c is now responsible for all type checking except for assignment and function argument ...” (9dc22b6d6f, 1141 insertions, 1363 deletions) and assignments, switch, if, for followed (d8c19c80dc). Select was split into typecheck + walk in its own file (f7a867e1a6); := and range processing were made lazy so declarations do not need order (54b403723b, 2609731736, old2new gone); var blocks evaluate lazily (dbe004efe4); and “forward declarations not necessary” (b648716ee9, 990 insertions, 668 deletions) deleted prototypes in favour of resolving names on demand (“excluding import data, no yacc node has type Type* anymore”, 35e5906f91). Package compilation became whole-package (66bb399fdd) and forward type declarations were deleted (a92610208e). Steps toward this: functions’ forward declarations (be16caf872, e52e9ca82e) and constants referring to later constants in a block (db508ccbff).

Remaining work was explicitly noted: “initializer cycle detection” and “nicer error for type checking cycles” (b648716ee9), later done with initialization-loop diagnostics (41861a8812, 896f0c61c8) and a typechecking loop detail message (2aafad25b4). In June 2010 “new typechecking rules” made assignment and conversion code mirror the spec, and renamed runtime functions to separate interface conversions from assertions (convT2I, assertI2T, 565b5dc076). Other stages: the real type of identifiers is tracked (49a835fc97); sort errors by line number (2372408189); typecheck the whole tree before walking, a prerequisite for escape analysis (e59aa8ea4a, Jun 2011, 177 insertions 345 deletions); builtins resolve to the built-in symbol (e77f057bf3). Type declaration cycles: type T *struct { T } as invalid embedded (6c2738eb43), recursive types (05a1eb1ab0), recursive interfaces (44898c7b76, 1734cb02e7), recursive forward references through pointer fields (b6f0632e93), and “typecheck loop” fixes (5e98505ba7).

Timeline.

• Go 1.0 — Done:
  • 2009: typecheck pass (9271c6402e, 9dc22b6d6f, d8c19c80dc), lazy declaration processing (dbe004efe4, 54b403723b, 2609731736), no forward declarations (b648716ee9, a92610208e), whole-package compilation (66bb399fdd), per-file filename disambiguation dropped (107d404378).
  • 2010: spec-mirroring conversion/assignment (565b5dc076), less aggressive name binding for line numbers (76da2780c3), types inside function bodies (17f90c68c6).
  • 2011: whole-tree typecheck (e59aa8ea4a), cumulative error count (3208917d54).
  • 2012: typecheck-loop diagnostics (2aafad25b4), field+method same name (7dd90621f8), return expression-list checks (1d3ca9236e). Left open: nothing noted.

Interfaces, type switches, assertions and comparability

Span: Go 1.0 → Go 1.0 · Status at go1.17: interface layout Eface/Iface and comparison rules as at go1 persisted; the runtime later moved to itab caches in Go-era reflect → continues as Type sets, union terms, interfaces and constraint satisfaction (1.18+)

Design. Interface support began as signature tables: i2s, s2i, i2i conversions (ead7a6d47a, 52861558f4), “interface on arbitrary types” with global signatures for basic types (1bf38484d1), duplicate interface signatures (0a7e4a7415), and sigt/sigi structures. On 2009-05-06 “new interface rules (code got simpler!)” (a6ba5ec535). On 2009-05-20 the representation changed: before, every interface value was {addr, Itype*} with Itype{Sigt *type; Sigi *inter; void *method[n]} acting as a vtable; now interfaces with static type interface{} use struct Eface {void *addr; Sigt *type}, which “reduces the number of Itypes that have to be computed and cached”, opens up avoiding calls, and lets interface{} values be laid out at compile time for the new reflection (2da5022bcf, plus ifaceop split into ifacecvt and ifaceop, a39bae095a). The runtime moved to reflect data structures in July 2009 (c7513eac88, 541e638f9b). Conversion rules: narrowing needs type assertions (5f4f5647ef), i.(T) requires non-nil i (23e62d169f), a heuristic complains when putting T in an interface when T has pointer methods (4eb7ceba58), conversion to interface type when implicit assignment would be okay (d436a70193), typed nil constants distinct from nil interface (a14b28a24d), unsafe.Pointer not a pointer (5c2666c18c), interface embedded in interface (b4af09ab56) and disallowed interface { x, y() } (7743ffead4), recursive interface embedding (1734cb02e7).

Type switches arrived 2009-03-06 along with removing typeof (a4a10ed856), got binary search and case nil (0f469a99a3), a rewritten switch (bf983477a2, 79fa5b65cb), and the unused-switch-variable error (aac144b120). Interface equality was first a runtime hack sys.BUG_intereq (827dcb86b7) until the compiler supported it (edb1412c50, 5933dbda3a).

Comparison and map keys were slowly formalised: map key types checked at compile time (98b34e5bbd), maps allowed as keys because maps have == (75fe1303c1), then the reverse: “remove func, map compare” (5bb54b8e9c) and “disallow map/func equality via interface comparison” (46deaa297b, Dec 2011), “new comparison rule” basing comparison compatibility on assignment compatibility (23bd214aee), invalid keys disallowed (7ca406396f), and in December 2011 == on structs and arrays: “structs or arrays that are ‘just memory’, like [2]int, continue to use the AMEM algorithm; those containing strings or interfaces use generated functions for equal and hash; the runtime helper runtime.equal(t, x, y) handles the general case; for short values (≤4 fields or elements) the elementwise comparison is inlined” (196b663075). Algorithm tables got specialised entries: word-sized copy/equal (4d903504b3, 0–6% regexp benchmark gains), slices and sizes 8/16/32/64/128 (54e9406ffb, ChanUncontended 226→94 ns) and zero-sized types (1ff1405cc7, ChanSem 127→78.6 ns). Floating-point map keys were handled in 2012 (408f0b1f74). Finally the predeclared error type was added (2a0e15d36c, Nov 2011) with a temporary GOEXPERIMENT=os.Error (47f4bf763d, “this won’t last long”), and GOEXPERIMENT=reorg to ease conversions (ae7a003cf9).

Timeline.

• Go 1.0 — Done:
  • 2008: signatures and conversions (ead7a6d47a, 1bf38484d1), interface equality (edb1412c50).
  • 2009: new interface rules (a6ba5ec535), Eface (2da5022bcf), type switches (a4a10ed856, 0f469a99a3), embedded interfaces (b4af09ab56), map key checks (98b34e5bbd).
  • 2010: new comparison rule (23bd214aee), recursive interfaces (44898c7b76), equality algorithm specialisation (4d903504b3).
  • 2011: algorithms (54e9406ffb), error and experiments (2a0e15d36c, 47f4bf763d, ae7a003cf9), map/func compare removed (5bb54b8e9c), struct/array == (196b663075).
  • 2012: zero-size algorithms (1ff1405cc7), comparison recursion fix (427b5bddcd), struct with _ field (c4c92ebeb6), float map keys (408f0b1f74). Left open: the pointer-methods heuristic was labelled a heuristic that “catches the problem” only (4eb7ceba58, 935953a9f8).

Embedded fields, method sets and receivers

Span: Go 1.0 → Go 1.0 · Status at go1.17: embedding via genembedtramp-style wrapper generation as at go1 → continues as Method receiver checking (1.18+)

Design. “Unnamed substructures” appeared in October 2008 (61361af9e8), then import/export of embedded types, auto-& on methods and embedded methods (21617250f4, 6fecb76eea, 7ed8fc611d, b642cf8c00). Methods on arbitrary types were stepped in: any type but only *struct tested (2119294af9, 89ac5618ac), slices as receivers (b2dfd787d7), funcs (5e2c05877d), chan/map/string once they were real types (316d377ac2), complex types (883d68f885), unnamed struct types (4267974c0b). An anonymous interface field m shows up in the struct’s method set (401a95aa83). Wrapper generation requires care with private methods in signatures (35e37bbf41), methods must immediately follow their struct (ef40d9435b), and in 2011 non-methods are kept out of xmethod (11075ed893) and copytype resets xmethod (ffa6b383f5). Method expressions on concrete types came in Dec 2009 (0d668259dc, 9e2c9bb0ca), receivers relaxed (0b209b36b6), invalid receivers explained (4684df520f, 6a401339c1), names made Go-like (1bd4b6371a), unexported methods of the same name no longer confused (987a580b9f), field-and-method same name diagnosed (7dd90621f8), ambiguous selector deduplicated (7ae1fe420e), pointer-to-pointer method call message (7df9ff5594).

Timeline.

• Go 1.0 — Done:
  • 2008: 61361af9e8, 6fecb76eea, b642cf8c00, method on *T names (258c817a1b).
  • 2009: methods on slices, funcs, chan, map, string (b2dfd787d7, 5e2c05877d, 316d377ac2), method expressions (0d668259dc).
  • 2010–11: 883d68f885, 0b209b36b6, 1bd4b6371a.
  • 2012: 4267974c0b, 987a580b9f, 7dd90621f8. Left open: nothing noted.

Closures

Span: Go 1.0 → Go 1.0 · Status at go1.17: closure conversion by value-or-reference capture classification as at go1; the compiler later rewrote it → continues as Frontend support for new language features and spec changes (1.18+)

Continues in: Closures, method values and variable capture (Go 1.1 → Go 1.7)

Design. Function literals first needed parameter-declaration parsing fixes (8003849498, 814320c8b4). Closures arrived with 6g support on 2009-02-06 (0970c46863, 251 insertions) building the closure via a runtime.closure call. Function literals are named _f007·filename-style to allow multiple closures per package (416b27548e); the outnamed flag is copied (941ed00b1d). Performance work was done by Luuk van Dijk in 2011: calls to function literals called in place skip runtime.closure (9b82408f6d; BenchmarkCallClosure 499→5 ns, CallClosure1 681→160 ns), merely referencing an outer variable in a closure no longer forces heap allocation (2c4edb0eea; 135→6 ns), and closures without closure variables omit the wrapper (ba25778f3f, Jan 2012). Bugs: closure bug (e8ff9a624f), top-level closure (890bdc5339), escape analysis + inlining + closure (075eef4018), loopdepth for labels (9bf3478658).

Timeline.

• Go 1.0 — Done:
  • 2009: 0970c46863, 416b27548e, 941ed00b1d.
  • 2011: 9b82408f6d, 2c4edb0eea, e8ff9a624f, 890bdc5339.
  • 2012: ba25778f3f, 075eef4018. Left open: closures containing closure expressions were excluded from inlining (a62722bba4).

Escape analysis and heap allocation

Span: Go 1.0 → Go 1.0 · Status at go1.17: first escape analysis enabled by default in esc.c → continues as the escape analysis in later threads; no 1.18 link.

Continues in: Escape analysis (esc.c → esc.go) (Go 1.0 → Go 1.9) · Escape analysis and stack allocation (Go 1.1 → Go 1.9)

Design. Early rule: taking the address of a local moves it to the heap (391425ae55), refined to not move x because of *&x (a75e347a21). On 2011-08-24 Luuk van Dijk added a real escape analysis, switchable with -s, effects inspectable with -m, defaults old paths (847b61b554, 945 insertions). Days later it was enabled: “-s now means disable escape analysis”, leaks for struct/slice/map literals fixed, ... tracking, new(T) and slice literal rewritten into stack allocation when safe, and annotations added to reflect (db5f9da425). Supporting changes: stack-allocated slice backing arrays are zeroed (c45c0c0c1d), a temp = nod+tempname helper (9854fd2a0e), FlagNoPointers passed to runtime.new (bf9c778fe2), loopdepth analysis for labels (9bf3478658), label recursion (60d47101aa), and the typecheck-whole-tree prerequisite (e59aa8ea4a). Goto restriction work removed stack frame zeroing (7f4c5ea7d8).

Timeline.

• Go 1.0 — Done: 391425ae55 (2009), a75e347a21 (2009), 847b61b554 and db5f9da425 (2011), c45c0c0c1d, bf9c778fe2, 9bf3478658, 075eef4018 (2012). Left open: nothing noted.

Inlining

Span: Go 1.0 → Go 1.0 · Status at go1.17: first inliner, evolved massively afterwards.

Continues in: Inlining (inl.c → inl.go) (Go 1.0 → Go 1.9) · Inlining (Go 1.1 → Go 1.9)

Design. Inlining is exported in the object file: export format changes in October and December 2011 (b536adbfba, 40b2fe004f) carry function bodies. a62722bba4 (2011-12-14) added “cross- and intra-package inlining of single assignments or return <expression>”, with hairy cases (calls, closures, ...) excluded, disabled without -l (824 insertions). Follow-ups: empty bodies and _ arguments (7e6890a670), inlining fixes (97fd7d5f34, 836a517f69, 524fb81c41), enabled by default 2012-01-10 (4a6b07f235), unsafe.Pointer permitted (2332439b1b, 1b19134c4f, 82a6a4f39e), minor changes (fc128403dc), append inlining of dst = append(src,...) (36cec789cd). The order of evaluation was repaired by a new pass that “moves things with a fixed order out of expressions and into the statement sequence”, because pulling calls out had caused illegal reorderings, worse with inlining (ee9bfb023a, Jan 2012, plus 5efd5624cc for && and ||).

Timeline.

• Go 1.0 — Done: 2011: b536adbfba, 40b2fe004f, a62722bba4, 7e6890a670. 2012: 4a6b07f235, ee9bfb023a, 2332439b1b. Left open: excluded calls, closures and ... (a62722bba4).

Builtins and unsafe

Span: Go 1.0 → Go 1.0 · Status at go1.17: builtin set as at go1 → continues as Language features as seen by the type checker (by release) (1.18+)

Design. The early sys package gave way to builtins: len takes an expression (b2d9020242) and fixed arrays (4c5a165873), print/println, printn/panicn (f21e731c71), panicln deprecated (623dfd1b07). Copy: copy without result (01c2de0c15), *[10]int to slice (9be56adf3c, removed by 82ee481dfc), copy([]byte, string) (82c6f5e3d1). append landed 2010-10-27 (d8b5d039cd), optimisation by dst = append(src, ...) inlining (36cec789cd), append([]byte, string...) (77fac21e82). Panic/recover: 01eaf780a8 (2010-03-30) enforced a single argument and 9b1507b050 implemented them; defer print etc. (a186b77b03). delete(m, x) was added while retaining m[x] = 0, false for a transition month (1d687c742d) and the old syntax removed (5fc3771b3a). close on receive-only channels disallowed (f58ed4e641). Unsafe: unsafe.Sizeof, Offsetof (8a70545b57), Alignof (651972b31f), then in 2011 returning uintptr (cf9f380499), non-call use diagnosed (924ea515cf), old unsafe functions deleted (1f2445d27b), unsafe.New (33649bd278), reflect moved into unsafe (c367d1b789). string(int)/string([]int) conversions (64c3fe05bf), []int(string), []byte(string) (3910161307), direct conversion string ↔︎ named []byte/[]rune (6e3e380923), and rune (6ed3fa6553, Oct 2011; “alias for int32”, 012798a325).

Timeline.

• Go 1.0 — Done: 2008: b2d9020242. 2009: 01c2de0c15, 8a70545b57, 64c3fe05bf. 2010: d8b5d039cd, 01eaf780a8, 9b1507b050, a186b77b03, 3910161307. 2011: 1d687c742d, 5fc3771b3a, 6ed3fa6553, 012798a325, cf9f380499. 2012: 1f2445d27b. Left open: nothing noted.

Channels, select, maps and strings as built-in types

Span: Go 1.0 → Go 1.0 · Status at go1.17: compiler lowering to runtime calls as at go1.

Design. Chan and map became real types after the pointer-removal (dc7b2e98d2). Select: first implemented 2008-07 (b78676a49d, cb9b1038db, ece3e57c85) with select default (79fbbe37a7), moved into its own file with typecheck + walk (f7a867e1a6), special-case code for single-op blocking and non-blocking selects (5038792837), made faster by passing a pointer to the element so Scase is fixed-size and Select, Scases and SudoGs allocated together (6b2ec06587, uncontended 1080→558 ns), and “select functions are no longer special” (22853098a9). Range over a channel was made safe for multiple goroutines (b0543ddd8a). Maps: literals (182f91ffe0), nil maps (65bde087ae) and nil channels (3770b0e60c), multivalue map index (0282cc5e74), correct typecheck of x, ok (b7c4314ecb). Strings: representation changed April 2009 (3657061550), range over strings (a91a8042b4), x[y:] for strings (aa4c638b7b), string-index code generation inline (e48c0fb562), efficient x + y + z (f47d403cb4). Large channel element sizes are rejected (d116a32727) and data types are limited to 1GB (7e7008fa5e).

Timeline.

• Go 1.0 — Done: 2008: cb9b1038db, 79fbbe37a7. 2009: 3657061550, a91a8042b4. 2010: f47d403cb4. 2011: 5038792837, b0543ddd8a, 65bde087ae, 3770b0e60c, 6b2ec06587. Left open: nothing noted.

Initialization and static data

Span: Go 1.0 → Go 1.0 · Status at go1.17: sinit.c static init as at go1 → continues as Static initialization and package init (1.18+)

Continues in: Static initialization, composite literals and init (Go 1.1 → Go 1.9)

Design. Package init order was added in July 2008 (fb3af53f4e, 90da636c15, f24f8ffae0); empty init functions are dropped (49f7494894); static initialization of slices (b91a043d02) was re-enabled (802e1a6104); recursive initialization is detected (e2613711aa) and diagnosed better (41861a8812); composite literals under init were moved from walk.c to sinit.c (0631d65dc5, 18f2e360a0); an optimisation of static initialization (33da9afc3e) with a read-only flag (d348971103, 103d756663); adjustable hash code in composite-literal typechecking to get rid of O(n^2) behaviour (b3dd22fecb, 8cb8ba14a5); init loops involving functions (896f0c61c8); stack allocation for the init function (1ea5bc7533).

Timeline.

• Go 1.0 — Done: 2008: fb3af53f4e, 1ea5bc7533. 2009: b91a043d02, e2613711aa, 0631d65dc5. 2010: 33da9afc3e, d348971103, b3dd22fecb. 2012: 896f0c61c8. Left open: nothing noted.

Composite literals

Span: Go 1.0 → Go 1.0 · Status at go1.17: Go 1 rules; type elision for struct/array elements came later.

Continues in: Static initialization, composite literals and init (Go 1.1 → Go 1.9)

Design. Array literals (4539ced714), map literals (182f91ffe0), key:val extensions in array and struct literals (a016081f43), constant array keys (18840f5429), &Point{1, 2} rewrite as allocation (beee6915f8), static init of literals (above). The December 2011 commits implemented “composite literals as per Go 1” (7dc9d8c72b) and removed type elision in struct literals (5cb1c82d96); [...][...]int{{1,2,3}} was disallowed (bf899befdb), slicing array literals not allowed (7d15eda95d), duplicate key shown in error (5ab9d2befd). The October 2010 version (8ffc4ec5d0) implemented the spec of that time for element elision.

Timeline.

• Go 1.0 — Done: 2008-09: 4539ced714, 182f91ffe0. 2009: a016081f43, 18840f5429. 2010: 8ffc4ec5d0. 2011: 7dc9d8c72b, 5cb1c82d96, bf899befdb. Left open: nothing noted.

Variadic functions (...)

Span: Go 1.0 → Go 1.0 · Status at go1.17: ...T as a property of func types.

Design. ... was a distinct, special type at first (74427c6346, 2fef4c7198); ... was double-checked (d122bb2193), allowed in method lists (101f499fa5), and then “add ... T, rework plain ...: no longer a distinct type; now a property of func types” (68796b0270, bea730d1f9); ... vs ...T crossing was an error “at least for now” (8bef7fdc39). Further ... changes and printing (75dd8fdb34, 1d315a8abd), an interim error rejecting valid code removed (2795b13156), and ... forbidden in type conversions (5b62ba14c4).

Timeline.

• Go 1.0 — Done: 2008: 74427c6346. 2009: d122bb2193. 2010: 68796b0270, 75dd8fdb34. 2011: 2795b13156, 5b62ba14c4. Left open: nothing noted.

Statement and flow rules

Span: Go 1.0 → Go 1.0 · Status at go1.17: Go 1 rules.

Design. Labels, break/continue/goto (33ee52727f), goto restriction that jumping over variable declarations or into blocks is an error (7f4c5ea7d8), terminating statement requirement “new return restriction” (c18d1a78a4), no implicit return in empty function body (0b2683d1ee), declared and not used (59914723df disabled initially), unused type-switch variable (aac144b120), write-only _ (5438be4541), error on redeclaration (54abac678a), nested function errors (371b77ad20).

Timeline.

• Go 1.0 — Done: 33ee52727f (2008), 59914723df (2009), 7f4c5ea7d8 and c18d1a78a4 (2011), 1d3ca9236e (2012). Left open: the unused variable check was disabled when added (59914723df).

Diagnostics, error recovery and compiler plumbing

Span: Go 1.0 → Go 1.0 · Status at go1.17: C compiler diagnostics; messages later shared with types2.

Continues in: Diagnostics and error messages (Go 1.1 → Go 1.9)

Design. Large numbers of “bug NNN” fixes track the test/bugs directory (193eac7917, 1cb7f85d74 “0 expected bugs”). Error-reporting infrastructure: syntax-error recovery (1efa6a0544, 417a971f9a), helpful error rules (46f89d53c6, d7c1048771), line numbers from yacc lookahead (4656686cf5, 38df5ec58d), pretty types with 6g -t to disable (387c1bc31e), expression printer %#N (4152b925f9), errors sorted by line (2372408189), duplicate errors removed (529369e452, 6865cc0e8e), original expressions preserved (8133cb3565), a fatal-bug vs error distinction (9475cafa73), graceful seg-fault exit (b49561d884), cumulative error count (3208917d54), debug-flag docs (4b6cd239c5), and -L full paths (779dfea487). Build plumbing: builtin.c.boot generated from runtime.go (d06a79e31b, 8b3b1edc04), golden copy (ce7f345cd1), generated y.tab.[ch] checked in (d53cdd1775), Plan 9 yacc (920df48fb1), clang support (60a4b5e4db, 6998ea2982), and the move of portable code from 6g into gc (531f242f5d, 8e54729b5a, d30285a6f5, bac922c6e1, 5e792b6c09). Alignment: 20cfa4a568 rolls the receiver into input parameters, outputs in their own struct.

Timeline.

• Go 1.0 — Done: as above in each year; 2009-03-30: portable code moves into gc (bac922c6e1, 5e792b6c09). Left open: nothing noted.

Changes in this slice that are not part of a thread are listed on the release pages: 1.0

Compiler frontend (Go 1.1–1.9)

Reader: Claude Sonnet. Cites 1,297 of 1,507 commits in this slice; every non-noise commit is cited, plus 30 larger commits the noise filter had set aside, which a separate gap reader described. Read the design-heavy messages and subject lines. Some timeline items are plain hash lists.

The C-to-Go translation of the compiler (cmd/gc → cmd/internal/gc → cmd/compile/internal/gc)

Span: Go 1.5 → Go 1.9 · Status at go1.17: done in 1.5; the Go gc package then became the single frontend, later split into syntax, types, ssa and so on → continues as Old typechecker and IR node-model cleanup (1.18+)

Design. Until Go 1.4 the frontend was C in src/cmd/gc (lexer lex.c, yacc grammar go.y, typecheck.c, walk.c, esc.c, inl.c, sinit.c, …) shared by the per-arch code generators 5g/6g/8g. The Go 1.5 cycle converted it mechanically to Go. The runtime-C-removal branch work started it: fd2bc95d53 ([dev.cc]) changed cmd/gc to emit an -asmhdr header (struct field offsets and consts that cmd/dist used to scrape from the C compiler), to accept //go:cgo_xxx and //go:linkname directives, and to hard-code that interfaces contain only pointers. The translated code was committed as cmd/internal/gc (9c8c0e729d “reconvert to pick up bug fixes”, f6791da7ad for new6g etc.), still driven by a Go-ported yacc (cmd/yacc, go.y → generated y.go). Matthew Dempsky’s cmd/yacc work restored the “unexpected X, expecting Y” syntax-error style that Bison produced (e7d9f81645, 398bf9d5a0, 4f2a73011f, 82e1651a24), and a1bb3030c8 made yacc emit arrays instead of slices.

C idioms were then peeled off: Strlit/Zconv deleted (bed1f90d08), C hash tables replaced by Go maps (d0b59deb71), md5.go replaced by crypto/md5 (392434e1d0), Mpint/Mpflt re-based on a vendored math/big (e5a0d6399e, 4da157a723, 888767fcc4, 5bb89eb009; the vendored copy was refreshed repeatedly: 1e48683708, 65cd1ba682, f39cca94af, 646939c0e3, 5693bee0f1), Val.U became interface{} (13485be939, Node 424→392 bytes) and many int flags became bools (4a174ee4be, 5bf428ef80, 7885de55dc, d328756a69, 75883bae28, e7fe9f56ea). The package was then moved to cmd/compile/internal/gc with the binary renamed from 6g to compile (b3a508c03e usage names).

The second half of the effort was memory: Node dominated compiler memory, so func-only, name-only and param-only fields were split out into Node.Func, Node.Name, Node.Param (57279ba752 504→416 bytes, 76ec0ee53a, f4ab8203ba, 3ed9e4ca3c, bd8bb67357), and a long series moved fields into those substructures and deleted dead ones (ffef180f82, 66be1481df, 496ad0a286, 4fdd53680c, 71080fbb9e, 60e5f5bdff, 140ef3c59a, ac2bda1b00, 3007e953d0, 11322d45a1, 3c3019aa51, fd2154f906, bd4fff6358, da094f19f1, f1f0eda446, 3be7f28e82, 81d5810be9). cd9f417dbb documented which Node fields each Op uses.

Timeline.

• Go 1.5 — Done: [dev.cc] fd2bc95d53 prepares cmd/gc for runtime C removal (-asmhdr, //go:linkname, //go:cgo_*, pointer-only interface data word); the compiler is converted to Go as cmd/internal/gc (9c8c0e729d, 6eaa095012 expands the DBG macro, d68f52aa43 restores mkbuiltin, 2bcfe8b935 NULL→nil, 8d44ede0dc “simplify code for c2go”); yacc ported with expecting-messages; math/big vendored; Node slimmed; package becomes cmd/compile/internal/gc (d00e7ad640 -d panic=1 to show compiler panics, 7bcc6a1615 -importmap, 442959ec47 fix builtin generation). Left open: the grammar is still yacc-generated y.go; NodeList linked lists and C-style global state persist.
• Go 1.6 — Done: leftovers cleaned: cb0e98b833 “fix some C to Go translation leftovers”, dd42eff8fe/703bd83623/22452ac592/dab0dac01a/391cc54da8/bab01a0b4b/d5fe165ca0/a2119aca7d/b9dbb030d5 convert ad-hoc NodeList uses to []*Node, 8712e1867b/8937780c8a/e03c7896a7/9ac0fff70a/a20fbe8e18 bool conversions, cd7d7382bb and 53d43cb556 introduce types for decl contexts and untyped constant kinds; b569b87ca1 replaces yacc (see parser thread). Left open: NodeList itself.
• Go 1.7 — Done: NodeList eliminated in favour of Nodes (see data-structure thread).

Parser: from yacc to a hand-written recursive-descent parser

Span: Go 1.1 → Go 1.8 · Status at go1.17: the gc-internal parser was removed in 1.8; the syntax package parser is the only parser → continues as The syntax package (parser, scanner, tree) (1.18+)

Continues in: The syntax package: parser, scanner, source reader, positions and error recovery (Go 1.10 → Go 1.17)

Earlier history: Lexer, grammar and statement syntax (semicolons, chan operators, conversions) (Go 1.0 → Go 1.0)

Design. In Go 1.1–1.4 the grammar was go.y with Bison (y.tab.c), custom error-message tables generated by bisonerrors (made compatible with Bison 2.7 e7ef3b6daf and 3.0 4eaf91a7a7), and a hand-written lexer (lex.c). Many error-message commits in these releases tweak the yacc actions (for example d00bd1d1f4 friendlier error for C-style if (i == 0), 9146ac14ee avoids parser stack overflow on a long else if chain, c956dcdc54 rejects parenthesized .(type)).

After the Go port (see previous thread) Robert Griesemer translated the grammar into a recursive-descent parser (parser.go) in b569b87ca1: “a translation of the yacc-based parser with adjustments”, yacc actions copied for correctness, enabled by default, -oldparser to revert; measured about 18% less parse time per file and about 3% less time compiling cmd/compile. Follow-ups made syntax-error handling and recovery match the old messages (c8bc7f1abd, ac658a83c2, 0133d24c94, 64cd86798b, aad18b849b, 656a732a21, 5500d46914 for &(T{}), 1a111ea2c7 for <-x vs <-chan), and b5fe07710f deleted go.y and y.go (6025 lines removed). In 1.7 the lexer was rebuilt around bufio.Reader directly (5aa5db7593, 539aa05a64 always use getr, 8dd2ce2b98 factor out literal lexing, aa5b44aeab set nlsemi where the token is identified, 071e43a958 keywords no longer Syms, 3c0fae5306 pragmas tracked in the lexer, 8fd7c11d59, e0fa809f4c rationalize lineno vs lexlineno, a5b7a8d6dd error sorting, 49d1e30710 binary-expression parsing shared with go/parser, f5f8b38462 removes prectab).

The parallel track was the new cmd/compile/internal/syntax package (see next thread). 2ff463948c introduced noder.go which converts the syntax AST into gc Nodes (hidden behind -newparser); adda7ad295 made it the default on 2016-08-16, and 57df2f802f removed the old lexer/parser in 1.8.

Timeline.

• Go 1.1 — Done: yacc era maintenance: 6ce4930365 accepts an initial BOM, 8f3b703323 complains about invalid whitespace chars, ffc742b658 accepts new conversion syntax, 27d17255db^1.2 inserts \n at end of every input file, 6592456feb. Left open: grammar tied to Bison.
• Go 1.2 — Done: b4e92cee97 and 8cd6341cf8 add full slice expressions x[i:j:k] to go.y (12 files; commit says “experimental … may not be included in the release”, then allowed in), see language thread; d00bd1d1f4 C-style-if message. Left open: nothing noted.
• Go 1.4 — Done: user-visible 8d504c4e97 for range x {; 2565b5c060 drops the parenthesization restriction for receiver types.
• Go 1.5 — Done: yacc ported to Go, expecting-messages restored (e7d9f81645), lexer allocation reduction 9f4c25e223. Left open: hand-written parser not yet.
• Go 1.6 — Done: b569b87ca1 recursive-descent parser (default), b5fe07710f yacc removed, 247959d9b8 rejects identifiers beginning with a non-ASCII digit, e18cd34c76 correct line for :=, fe762b6466 parenthesized go/defer message. Left open: gc’s parser still builds Nodes directly, not a separate AST.
• Go 1.7 — Done: lexer/parser simplifications listed above; 3a11c8d319, e4571d33ac, 9f301643bd/bb3b10214d (parameter parsing without OKEY nodes), 135109d241. Left open: new AST parser exists only as an unused package.
• Go 1.8 — Done: 2ff463948c + adda7ad295 noder on by default; 57df2f802f old lexer/parser removed; 2d4d22af7e parser.go remnants moved into noder.go; ee161e8591 pragmas handled immediately; 70544c91ff “match old parser errors and line numbers”; 117793624b syntax exposes extra info for gc; 2d136ae82e //line filename:line with ‘:’ in file name; 7a26d9fced, 322436b78c, 60a9bf9f95 Read/Parse error handling.

The syntax package, position representation and parse-time checks

Span: Go 1.8 → Go 1.9 · Status at go1.17: still the design (syntax tree with Pos and PosBase; branch checking in the parser) → continues as The syntax package (parser, scanner, tree) (1.18+)

Continues in: The syntax package: parser, scanner, source reader, positions and error recovery (Go 1.10 → Go 1.17)

Design. c8683ff797 (2016-03-04, in go1.8) added cmd/compile/internal/syntax: “fast Go syntax trees”: nodes, scanner, parser and printers, building trees for the whole std lib at about 1.8M lines/s and 282 MB allocated for 1.07M lines. Its error messages were aligned with the old parser (70544c91ff). In the 1.9 cycle the representation of positions was redesigned on the [dev.inline] branch: 8d20b25779 introduced a general syntax.Pos plus PosBase (line-directive aware), 32bf2829a1 processed //line pragmas in the scanner, 24597c080b introduced cmd/internal/src.Pos, 4808fc4443 replaced src.Pos/LineHist with syntax.Pos throughout (the commit notes that compiler data structures grew, with Template compile up by about 9.5% and Compiler by about 4% in compilebench), and 33c036867f removed LineHist. The column unit was set to bytes (f3b56de4d2, 1f9f0ea32b starts columns at 1), and 5267ac2732 removed the gcCompat flag and set node positions “in a principled way”: the position of an Operation is that of the operator, so a + b + c has different positions for the two additions; this changed export data and pcline tables so it did not pass toolstash. e0329248d5 added positions for { and } (1.9% more node memory), b5f81eae17 replaced inlined statement lists with BlockStmt (+0.4%), f37ee0f33b records the column at function end, d1f5e5f482 “always construct a correct syntax tree”, and 2a5cf48f91 made error messages print line:col (byte offsets; -C flag to disable and planned for removal).

Two compile-time structural changes rode on the syntax tree. Files are parsed concurrently (ec63158d71, with b90aed020d reorganizing file parsing and e48919bcde splitting mkpackage). Label and goto checking, first a separate checkcfg.go pass over Nodes (c03e75e539, 299 lines, so that SSA generation can skip dead code), was moved into the parser as syntax/branches.go (912a638b0c, with a CheckBranches mode flag so tests that only care about syntax can switch it off; also fixed the issue 8042 “jumps over declaration” reporting), with bb70f517e9 reporting the innermost block for gotos jumping into blocks and a50962131a computing BranchStmt.Target. style cleanups aside, 912a638b0c also removes the dependency on the symbol dclstack.

Syntax error quality got a long tail of work in 1.9: 9799622f09 distinguishes ; from newline in messages, 3c22e5ca27/53c6ac5419/f823d30514/efb3cab960 improve errors for malformed if/for/switch headers and var decls in init clauses, 1693e7b6f2 character literals, d390283ff4 compiler directives must start at the beginning of a line, 5e954047bc/ee2f5fafd8/b5e1ae46ad tolerance and crash fixes, 422c7fea70 rejects declarations in a for post statement.

Timeline.

• Go 1.8 — Done: c8683ff797 package added; used by noder from 2ff463948c (default adda7ad295); 32db3f2756 support for alias declarations in the syntax package (see alias thread); cfc0d6d884. Left open: positions still based on the gc LineHist/lineno model.
• Go 1.9 — Done: Pos redesign (8d20b25779, 32bf2829a1, e97c8a592f, 3d5df64b3f, 4b8895e2dd, 24597c080b, 4808fc4443, f3b56de4d2, 2d429f01bd), principled node positions (5267ac2732), columns in errors (2a5cf48f91), concurrent parsing (ec63158d71), parse-time branch checking (912a638b0c), brace positions (e0329248d5); d10b50dc34 print positions in tree dump. Left open: the -C flag is expected to be removed eventually (2a5cf48f91); the gc Node tree still exists as a second representation (“Phase 3 is planned for eventual removal”, 756b9ce3a5).

Binary export data and the object-file split

Span: Go 1.1 → Go 1.9 · Status at go1.17: binary export format (v1..v5 “bexport”/“bimport”) plus inlined bodies; later replaced by the indexed format and then unified IR → continues as Unified IR: one serialization for noding, stenciling, inlining and export (1.18+)

Continues in: Indexed export format and the export-data lifecycle (Go 1.10 → Go 1.17)

Earlier history: Export/import data format (Go 1.0 → Go 1.0)

Design. Export data in Go 1.1–1.5 was text: a $$ section of Go-like declarations written by export.c, parsed by the ordinary lexer/parser. Inlinable bodies were exported as source-like fragments, which made inlining bugs show up as export-data bugs: 8d95245d0d, 761830f481, fc7b75f216, 78f5b616fc, 62891fb811, 20ebee2c31 and c1fc8d5296 all repair missing or corrupted body exports; constants were exported in hexadecimal (fbaf59bf1e) and later without the original expression (f09887cdce).

Go 1.6 added ae2f54a771, Robert Griesemer’s compact binary export format (bexport.go/bimport.go) under -newexport, importable in “mixed mode” with the textual format; export sizes were about 26–30% of the textual size for std packages in the commit’s table. It initially lacked inlined function bodies. Binary-escaping (e6ccfc1ad1: no $ bytes inside) and -importmap before unsafe handling (a8fc547f78) followed. In 1.7 4598382724 exported and imported all bodies without hooking them up, a9ea36afbb completed body export (three sections: platform-independent objects, objects pulled in by inlined bodies, and the bodies themselves; “completely compiler-specific and easily changeable”), compiler-specific flags moved to a compiler-specific section (b1851a3c11, 7d0d122247), position info was added (5c593a3227 “first cut”, delta-encoded line numbers and canonicalised strings, 14% size increase; e8d4ffb766 fixed the node used; 6c11e2710e delta-encoded filenames, 15–25% savings on some packages; 889c0a66fc disabled position export “for now”), and 7538b1db8e switched to binary by default on 2016-04-15, quoting ~65% smaller export data, at least 62% faster writes and 37% faster reads, with -newexport=0 as the escape hatch. feb6131b1a added -linkobj to write the object in two parts (export data for compiles, everything else for linking) and moved two bits the linker needed into the object header proper.

Go 1.8 removed the textual format (b4e9f70412, f50ced6d73, 074d6a649c), then reintroduced version-0 binary reading (c85b77c22b) and added a version byte with graceful failure on skew (5a6f973565), and exported aliases (03d81b5ed9, later revert of user visibility 8e970536df). 1.9 added linknames to export data (e3efdffacd: lets -l=4 inline functions that contain linknamed calls), position info in inlined bodies (9fd359a29a: +8–20% export size, accurate line numbers for cross-package inlining), type-alias format (49de5f0351: embedded-field name modes), interface embedding information (ee272bbf36), a cheaper position encoding with a -64 new-file marker and /-component paths, bumping the version to 5 (a6b16e0024: about 8% smaller), ad8c17b703 not exporting dead code in inlinable functions, and ff0748670c/2123a6c644 fixes for exported bodies and line-directive-relative positions.

Timeline.

• Go 1.1 — Done: inlining makes export data carry bodies, with a stream of bug fixes (8d95245d0d, 761830f481, fc7b75f216, 9e66ee4562, b0bb6f8cee, a9f1569e7b BOM escaping, a45777fe99 don’t export embedded builtins, 561edbd63c no useless private symbols, 8fff2525cb, fbaf59bf1e). Left open: export is source text.
• Go 1.2 — Done: 78f5b616fc, 62891fb811, 20ebee2c31, c1fc8d5296, a85cfbd433 (tag builtin error/byte/rune so they are not exported), 8d6bc666fb (qualified embedded fields with owner package), a9e119ac70. Left open: nothing noted.
• Go 1.3 — Done: 20137eb4b9 preserve qualified names of unexported methods; b022334029 -pack flag.
• Go 1.5 — Done: f09887cdce no original expression in exported constants; 7c3eeda66f go.builtin package prefix; bed481d683.
• Go 1.6 — Done: user-visible ae2f54a771 binary format behind -newexport, 3d3bc88bb5 export list as slice, e6ccfc1ad1, 92ba69d216, 91c8e5f80b, d37d76af43, ab5d2bf92f (don’t export Note field in bodies), feb2a5d610. Left open: no inline bodies in binary form; not default.
• Go 1.7 — Done: 4598382724, a9ea36afbb, 5c593a3227, 7538b1db8e (default), feb6131b1a (-linkobj), a5cd53a9fd invalid types/constants, d78c84c419 sorted imports for canonical obj files, 6e4a8615f6 deterministic output via AbsFileLine, eb4d1be285 keep variable numbering for inlinable exported funcs; 80e9a7f079 all-or-no named params, 8650c23034 verify imported types after full import, 87a2ae1fa2, ef62f641c3, 21d781070c one format for builtin calls, 054a721dca safemode bit from package header, 30282b091d labels/goto/fallthrough import, bbd1dcdf7d, 575a871662 //go:nointerface, 15f7a66f36 blank names, 1402e522c6 load builtin export data once, d930d69fd9, 113c4d2581/7d3a40978a refactor import/export parsing, 7d80291c4c, f8e41f6f59, 699a2ba137, 338a891e79, 3e40f13cf3, e7524d51fd removal of lexer-IO-state globals (the “Io” type). Left open: position export disabled “for now” (889c0a66fc) and parameter numbering kept (0b8c0767d0).
• Go 1.8 — Done: b4e9f70412 textual removed; c85b77c22b/5a6f973565 version handling; b11c79fd07; 03d81b5ed9 alias import/export; bcc0247331 avoid double export of aliased objects; 6394eb378e blank struct fields’ package; 14efaa0dc3 qualify unexported fields of unnamed types; 9aea69d6dc; 595cebb055; c7b9bd7456 self-recursive interfaces; f50ced6d73.
• Go 1.9 — Done: e3efdffacd, 9fd359a29a, 49de5f0351, ee272bbf36, a6b16e0024 (v5), ad8c17b703, 2123a6c644, a680a85ea7 simplify export info, ff0748670c. Left open: the format is still a sequential stream; ebcdda4732 and eb86abaa36 improve importer failure modes only.

Inlining

Span: Go 1.1 → Go 1.9 · Status at go1.17: the Node-based inliner with budget 80 survives, extended later (mid-stack, then PGO) → continues as Compile-time performance, concurrency and the self-PGO’d compiler (1.18+)

Continues in: Inlining: budget, mid-stack inlining, closures, and what became inlinable (Go 1.10 → Go 1.17) · Inlining-related frontend work: export of bodies, type switches, closures, devirtualization (Go 1.10 → Go 1.17)

Earlier history: Inlining (Go 1.0 → Go 1.0)

Design. Inlining (inl.c/inl.go) works on the typechecked AST: ishairy decides eligibility by a node-count budget, the callee body is deep-copied (treecopy/mkinlcall) with parameters turned into assignments to fresh locals, and the body is exported so importing packages can inline too. Go 1.1 widened it to functions with local variables (530147e870, with cb856adea9 annotating locals with unique ids so copies get distinct names, ae5e791ed2 saving the local var list before inlining, dfdfba14b9 letting temporaries from inlining be registerized), fixed a series of inlining-related miscompiles (b6ea905ed9 receive operator, a4682348c2 complex literals, 319131f295 composite literals in if, 9aef20e823 embedded builtins, 49da9a8e44 unnamed structs with embedded fields). Go 1.5 added transitive inlining (77ccb16eb1: calls that are themselves inlined away no longer block inlining of the caller, together with a larger budget so heapBits.next inlines; html/template compile time −12%). Go 1.7 allowed bodies that declare constants (fc6bcdee79) and switch (e41f527f4d, with a follow-up ac8d97b679), and Go 1.8 added -m-style explanation of why a function is not inlined (e4cae432d6) and stopped considering recursive calls (376d9665a8). Go 1.9 stopped counting statically dead if arms toward the budget (566e72d0ce, newly inlinable: bits.OnesCount, (*Float).Sign, etc.), then removed dead if code once after typechecking instead (dffe5ac9f2, with the caveat that labelled/goto code is kept), fixed names of inlined methods from other packages (83843b1610) and positions of inlined bodies via export data (9fd359a29a).

Timeline.

• Go 1.1 — Done: 530147e870, cb856adea9, dfdfba14b9, ae5e791ed2^1.2 (1.2), fixes b6ea905ed9, a4682348c2, 319131f295, 9aef20e823; 8d95245d0d export data for inlined local variables. Left open: inlined bodies that contain calls are refused so runtime.Caller cannot observe inlining.
• Go 1.2 — Done: 49da9a8e44, ae5e791ed2.
• Go 1.5 — Done: 77ccb16eb1 transitive inlining; 2e4b659954 embedded field in inlined function; ec0ebc2281 non-local vars inlined into wrappers treated as escaping; 4224d81fae inline x := y.(*T).
• Go 1.7 — Done: fc6bcdee79, e41f527f4d, ac8d97b679, a9ea36afbb makes imported bodies actually available; 17db07f9b5 don’t discard empty inlinable functions.
• Go 1.8 — Done: e4cae432d6, 376d9665a8; c7b9bd7456.
• Go 1.9 — Done: 566e72d0ce, dffe5ac9f2, 83843b1610, 9fd359a29a. Left open: the “unexported funcs are never inlinable across -l=4 with linknames” issue fixed by e3efdffacd; inlining remains leaf-only (calls block inlining).

Escape analysis and stack allocation

Span: Go 1.1 → Go 1.9 · Status at go1.17: the 2012–2015 flow-graph analysis (esc.go) with param tags remains; rewritten in later releases → continues as Old typechecker and IR node-model cleanup (1.18+)

Continues in: Escape analysis: the esc.go fixes, the escape.go rewrite, and the move to package escape (Go 1.10 → Go 1.17)

Earlier history: Escape analysis and heap allocation (Go 1.0 → Go 1.0)

Design. Escape analysis (esc.c, later esc.go) assigns each Node a “loop depth” and tracks whether addresses flow to the heap, to a longer-lived scope, or to results, producing per-function parameter tags used at call sites. Go 1.1 added tracking of the flow from input to output parameters (976ca1a47d step 0 synthesizes names for anonymous results, 75692424d2/507fcf37d2 the analysis, 572d984eaa, 71282131a1 fixes), applied results to closures (9fe60801ae: avoids allocating closures used as “macros”, defer args or Walk idioms; BenchmarkCallClosure1 119→7 ns), handled method values (38e9b0773d) and added a noescape marker for extern funcs (fd178d6a7e). Go 1.2 moved big stack variables to the heap (1f4d58ad5d) and fixed wrapper escape analysis (7cfa8310c7). Go 1.4 made it run always, even in -N mode (00d2f916ad) and fe3c913443 fixed an unsoundness with functions returning an indirection of a parameter, which mattered once stacks were copied (heap objects pointing at stack variables would not be updated). The fix tags such parameters as “content escapes” without recording which result; a more precise mapping was explicitly left out as a trade-off (more precise means fewer heap allocations).

Go 1.5 improved flow precision (7fbb1b36c3, David Chase): the per-function summary records outK = paramJ, outK = *paramJ, heap = paramJ, heap = *paramJ in a tunable number of bits (2 chosen), “level” split into three parts to model address-of cancelling indirection; 420 fewer heap allocation sites compiling std and a 15% reduction in allocations performed by the compiler on html/template. Dmitry Vyukov’s series then used escape results to stack-allocate more: 32-byte buffers for non-escaping []byte→string and concatenation (e6fac08146), []byte(str) conversions (9568126f35), string(rune) (4ce4d8b2c4), non-escaping make(map) with hmap and one bucket on the stack (b3be360f16, 75 std cases, NewEmptyMap 124→55.7 ns), interface backing storage (2270133981), &T{} like new(T) (2af3cbe308, 1.1), and no copy for range []byte(str) (71be013842). Go 1.5 also ran escape analysis after method-wrapper generation (5be61b18d4); Go 1.7 eliminated PPARAMREF (20803b845f), changed liveness handling of heap-escaped params with the new PAUTOHEAP pseudo-class (b6dc3e6f66), and stopped leaking dottype expressions (5c5e8d4105). Go 1.9 stopped updating outer variables after capturevars completes (61336b78c1) to make results deterministic under concurrent compilation.

Timeline.

• Go 1.1 — Done: 976ca1a47d, 75692424d2, 507fcf37d2, 572d984eaa, 71282131a1, 9fe60801ae, 38e9b0773d, fd178d6a7e, 2af3cbe308. Left open: only a single bit of flow info per param.
• Go 1.2 — Done: 1f4d58ad5d, 7cfa8310c7.
• Go 1.4 — Done: fe3c913443, 00d2f916ad, a3416cf5cd-adjacent write-barrier work lives in the GC thread. Left open: result mapping is not recorded; imprecise.
• Go 1.5 — Done: 7fbb1b36c3, e6fac08146, b3be360f16, 2270133981, 9568126f35, 4ce4d8b2c4, 71be013842, 5be61b18d4, 3bf005cea3. Left open: “ought to yield better results with a more competent escape analysis algorithm” (7fbb1b36c3).
• Go 1.7 — Done: 20803b845f, b6dc3e6f66, fb2af2b35b, 7e88826a69 (escape reads function decls instead of OTFUNC node slices).
• Go 1.9 — Done: 61336b78c1, ecc6a81617 (walkexpr must not modify ONAME/OLITERAL/OTYPE nodes, for concurrency).

Closures, method values and variable capture

Span: Go 1.1 → Go 1.7 · Status at go1.17: still the design (capture by value when never reassigned and not address-taken; closure call → function call) → continues as Old typechecker and IR node-model cleanup (1.18+)

Earlier history: Closures (Go 1.0 → Go 1.0)

Design. Closures are OCLOSURE nodes whose body becomes a hidden top-level function (25922c0658 introduced hidden closure functions earlier in Go 1.1). Method values x.M (d3c758d7d2, 1.1) are compiled as closures over the receiver (176 lines in closure.c). Go 1.5’s Dmitry Vyukov work changed the capture model in two steps. 0e80b2e082 “capture variables by value”: the spec says capture by reference, but if a captured variable is neither address-taken nor ever assigned after capture it is effectively const, so the closure copies it; about 80% of std captures became value captures, with zero heap promotion of PPARAM to PPARAMREF (BenchmarkCompressedZipGarbage allocs 153→126). Range variables and outputs needed special-casing (eaa872009d, 3bf005cea3). c4ee44b7b9 transforms direct closure calls (func(){...}(), go func(){}(), defer func(){}()) into plain calls with closed variables passed as arguments, so no heap context is needed (CreateGoroutinesCapture 6→2 allocs); it split the work into capturevars (decides capture mode, needed before escape analysis) and a new transformclosure pass run just before order/walk, and the call-site rewrite happens in walk of OCALLFUNC(OCLOSURE). Closure names became simpler (3a0fbfab57), called closures get captured args prepended to their params (731dcdae6d), and Go 1.6 made captureless closures constants (4f97ec0866): they can initialise globals at link time, which removed fmt.ssFree’s reachability from fmt.init and shrank hello-world by about 4%. In Go 1.7, PPARAMREF and Func.Outer were deleted (20803b845f, 93369001c7), Func.Cvars became a Nodes (52d9479e3b, 922ce58de0) and transformclosure was simplified (c7917de0bb); b64f549ba9 added -d closure and detection of leaking closures in the runtime.

Timeline.

• Go 1.1 — Done: user-visible d3c758d7d2 method values (also 20e05303fe variadic flag, 38e9b0773d escape, a9e119ac70^1.2 unnamed interface receiver in 1.2), 25922c0658, 9fe60801ae, ba0dd1f139 missing-return line in closures. Left open: all captures by reference.
• Go 1.2 — Done: 0d0d57ccfe (_ initializers in closures), 280c8b90e2 unique method names for function-scoped types.
• Go 1.4 — Done: 6c0bcb1863^1.3 (method value closures on nacl, 1.3).
• Go 1.5 — Done: 0e80b2e082, eaa872009d, c4ee44b7b9, 3a0fbfab57, 731dcdae6d, 27edd7209e (PAUTO capture variables on non-amd64). Left open: nothing noted.
• Go 1.6 — Done: 4f97ec0866.
• Go 1.7 — Done: 20803b845f, 93369001c7, b64f549ba9, e0f986bf26 (function literal name collision with “glob”), c7917de0bb.
• Go 1.9 — Done: 61336b78c1.

Language changes and rules as implemented in the compiler

Span: Go 1.1 → Go 1.9 · Status at go1.17: each rule is part of the language; implementation later moved to types2 → continues as Frontend support for new language features and spec changes (1.18+)

Paths not taken: Quaternion types (never landed)

Continues in: Language version gating (-lang) and language changes implemented in the frontend (Go 1.12 → Go 1.17)

Design. The gc typechecker (typecheck.c, then typecheck.go) implemented each spec change as a mix of grammar edits, typecheck rules and walk lowering. The log shows these language changes (the user-visible bullets in the timeline):

Go 1.1 spec changes. Method values (d3c758d7d2). “New return requirements”: a function with results must end in a terminating statement, implemented in typecheck by ecab408c42 (145 new lines, removing a walk check). The revised rule for shifts in equality comparisons (465ff4cfc0), shift defaultlit in interface context (1947960a6f), untyped complex inference (861aa4698a), integer-valued idealized floats allowed as indices (88b98ff791), bool losing idealness under logical operators (5188c0b59c), rejection of selectors on blank (b65acaeab2), methods on non-locals (7c3694c4de), division by constant zero (ba05a43608), “latest rules for checking make sizes” (f02067a99a), and bounds checks of constant indices/slices in typecheck (85d60a727c, 72bf3bc176, e3977f0d3a). ced8004a00 rejects (**T).Method expressions.

Go 1.2. Three-index slices x[i:j:k] (b4e92cee97, “Design doc golang.org/s/go12slice … experimental”; 8cd6341cf8 lets it into the release), including escape/racewalk/fmt support and per-arch cgen.

Go 1.3. Zero-length arrays are not comparable (502958ffa6), duplicate-key check for maps with interface{} keys (3072df5c1d, fixed again by ec38c6f5e3), fallthrough misuse rejected (96678f9dc0), float rounding and exponent range fixes (cb50277510, a43673cf8a, 60be4a2450, 1be479df92).

Go 1.4. for range x {} (8d504c4e97), pointer constants disallowed (7f40e5e6e5), short variable declarations with duplicate symbols prohibited (55df81d37f), blank methods in interfaces disallowed (db4dad7fd7), **T method calls disallowed (93fcb92257), initialization cycles through method values detected (fe8f799ef7), bounds error for out-of-range constant string slices (870f4e190c).

Go 1.5. Logical operators on untyped operands produce untyped bool (5cc29ab95e), method selectors no longer auto-dereference a named pointer type (b59dd94f33), map index expressions allowed in for range (b581ca5956), map literals may omit the key type (73d109c509), str[i] has type byte (c735064cde), unsafe.Pointer constants may only be converted to uintptr (a3dfcf51c6), detection of bad append(f()) (3f209abb29), goto validation ignores type declarations (5726af54eb), p-notation floats rejected in source (596bb76248), and an error if only one argument to complex (cb1897a58c).

Go 1.6. Rejections and fixes to constant typing: 336c998291 slice/map/func comparison against converted nil, be20948e27 bool(true) is a constant expression, 27691fa467 !typedbool is typed (so const _ bool = !mybool(true) is no longer accepted), c488548967 labels with package names, d6a203ecab const and label names may match, 67722fea50 invalid unsafe.Sizeof([0]byte{}[0]).

Go 1.7. 49dad0f571 arbitrarily deep embedded fields (the 1.7 compiler removed the limit), 75b886ab79 rejects embedded unsafe.Pointer, 3eaa304629 ignore receiver name when finding duplicate methods, f5423a63df a dot expression cannot be a struct literal key, e48a2958d1 empty and absent struct tags are identical, c97ddf9c10/f229e46783 assignment error fixes (“cannot assign to struct field in map”).

Go 1.8. 8895a99c9f typed non-integer constants as len/cap args to make are disallowed, 7f1bc53379 only integer constant keys in array literals, 39055700b1 ignore struct tags when converting between structs (the Go 1.8 spec change), 936ae27b9c untyped array bounds representable as integers are valid, fc5df089da constant comparison fix.

Go 1.9. 660200528a no implicit dereference of pointer-to-array for real/imag, 829adf5047 real/imag of untyped constants, c9446398e8 composite-literal structs with _ fields, 422c7fea70 no declarations in for post, 5f5d882f5c bad pragma combinations earlier, 10a200e560 division by complex zero.

Type aliases are in their own thread.

Timeline.

• Go 1.1 — Done: user-visible d3c758d7d2 method values; ecab408c42 return requirements; 465ff4cfc0, 1947960a6f, 88b98ff791, 5188c0b59c, 861aa4698a, 401e0fea3a (reject complex calls with mismatched args), f02067a99a, ba05a43608, ced8004a00, c956dcdc54, ffc742b658 (new conversion syntax), 04098d88fa (forward declaration in pure Go package is an error), 3aed92f811 (var/type/const named init), 87c35d8df1 (qualified names as literal keys), 6cbf35c172 (init order with method calls), 85ce3c7241. Left open: nothing noted.
• Go 1.2 — Done: user-visible b4e92cee97, 8cd6341cf8; 880d869764 init order for top-level blank vars; 66c8935f73 initialization loop detection; 933d7129c0; 903c2fda18 (_ = nil).
• Go 1.3 — Done: user-visible 502958ffa6, 3072df5c1d, ec38c6f5e3, 96678f9dc0, f3ecb298ad (builtin calls in len(fixed array) constants), e5f01aee04 (don’t nop-convert equivalent but different interface types), a069cf048d unnamed vs blank-named results.
• Go 1.4 — Done: user-visible 8d504c4e97, 7f40e5e6e5, 55df81d37f, db4dad7fd7, 93fcb92257, fe8f799ef7, 870f4e190c, 2565b5c060.
• Go 1.5 — Done: user-visible 5cc29ab95e, b59dd94f33, b581ca5956, 73d109c509, c735064cde, a3dfcf51c6, 3f209abb29, 596bb76248, cb1897a58c, 5726af54eb.
• Go 1.6 — Done: user-visible 336c998291, be20948e27, 27691fa467, c488548967, d6a203ecab, 67722fea50, 8a34cf7ee0 (no blank methods on builtins), b60c8203ea.
• Go 1.7 — Done: user-visible 49dad0f571, 75b886ab79, 3eaa304629, f5423a63df, e48a2958d1.
• Go 1.8 — Done: user-visible 39055700b1, 8895a99c9f, 7f1bc53379, 936ae27b9c.
• Go 1.9 — Done: user-visible 660200528a, 829adf5047, c9446398e8, 422c7fea70, 10a200e560, 5f5d882f5c, type aliases (see next thread).

Type aliases (the => experiment and type A = B)

Span: Go 1.8 → Go 1.9 · Status at go1.17: type A = B is the language feature; the first implementation was reverted in 1.8 and redone on [dev.typealias] in 1.9 → continues as Generic type aliases and Alias type nodes (1.18+)

Design. The first attempt (Go 1.8 cycle) added alias declarations to the new syntax package (32db3f2756) and package-level aliases to the compiler (1b0cf430dd, “requires -newparser=1”, then c0e2318f7c simplified parsing), using the => notation (89632aa183: “type T = p.T” disallowed, must use =>; 50f66fbb66 disallows init as alias) with import/export of alias declarations (03d81b5ed9, bcc0247331 avoiding double export). On 2016-11-04 8e970536df reverted the user-visible parts (“Decision to back out current alias implementation”), leaving import/export code in place. The second attempt came after the decision to use = in the spec: 3e11940437 ([dev.typealias]) recognized the syntax but complained, 49de5f0351 defined a tentative export/import format (embedded fields get three modes: name equals type name and exported, same but unexported, @+field name when different), f011e0c6c3 made related fixes in compiler, go/types and go/importer, b2386dffa1 type-checked alias declarations (known issues listed in the message: duplicate method declarations through alias names not detected, cycle error messages, byte/rune setup), 5c160b28ba improved cycle errors, de2e5459ae declares methods after resolving the receiver type, 9ecc3ee252 avoids false-positive cycles from aliases (fixes #18640) and 5d92916770 changed Func.Shortname to *Sym.

Timeline.

• Go 1.8 — Done: 32db3f2756, 1b0cf430dd, c0e2318f7c, 89632aa183, 50f66fbb66, 03d81b5ed9, bcc0247331, 8e970536df (revert of user-visible parts). Left open: “Leaving import/export related code in place for now”.
• Go 1.9 — Done: user-visible 3e11940437, 49de5f0351, f011e0c6c3, b2386dffa1, 5c160b28ba, de2e5459ae, 9ecc3ee252, 5d92916770. Left open: b2386dffa1 lists “needs many more tests”, undetected duplicate methods and byte/rune alias setup.

Constant arithmetic, Mpint/Mpflt and floating-point constants

Span: Go 1.1 → Go 1.9 · Status at go1.17: big.Int/big.Float-based constants (Mpint, Mpflt) → continues as Old typechecker and IR node-model cleanup (1.18+)

Continues in: Constants: Go 2 number literals, evconst, untyped conversion and go/constant (Go 1.11 → Go 1.17)

Earlier history: Constants and multi-precision arithmetic (Go 1.0 → Go 1.0)

Design. Constants were represented by Val with arbitrary-precision Mpint (fixed array of limbs, 464 bits then 512) and Mpflt (hand-written multi-precision floats in mparith), plus Mpcplx. In Go 1.1–1.4 work was bug fixing: complex literals (15bc7ab957), fixing inverted comparison order in mpcmpfltc (f85ba7d50a), exponent overflow and underflow checks (cb50277510), rounding of large negative exponents toward zero (a43673cf8a), float32 conversion and printing (60be4a2450, 1be479df92), ovf in mpaddxx message (397f129daf), isgoconst crash (32dffef098). Go 1.5 replaced the limb arithmetic: Mpint on math/big.Int (888767fcc4), Mpflt on big.Float (5bb89eb009, via a vendored cmd/internal/gc/big because the real math/big had no Float yet), after which a51d5f27e8 set multi-precision to 512 bits and 1122836b5f rejected huge exponents without math/big; 85de30e72f (1.6) allowed huge right shifts and 715f63778d avoided converting huge floats to integers; 76285213b8/79a3b561b5 removed -0 special handling (“there are no -0 floating-point constants”). Go 1.7 turned Mpint/Mpflt functions into methods (d3253876f2, 0659cf6911) and added special-casing for comparisons against zero (07749aef98), and 97360096e5 replaced Ctype switches with type switches. 1.8 and 1.9 refined diagnostics: e99dafc4a8 reworked the “truncated to int” messages (“integer too large” instead of overflow wording; SetFloat returns bool), 871300308a, bcf2d74ce8 large exponents, 2e60882fc7 no duplicate error on ideal→float overflow, ff3a4ef7ec less reliance on Mpint internals, 2acd3fa8f1 fewer switch cases in evconst, b83a916f71 iface == iface constant evaluation respects !=.

Timeline.

• Go 1.1 — Done: 8931306389 reject non-Go constants, 0184081eb9 small TPTR64 as integer constants, a85fce282e simplify defaultlit, bf59aafddc, 08918ba438.
• Go 1.3 — Done: cb50277510, a43673cf8a, f85ba7d50a, 60be4a2450, 1be479df92, 74ce581b06, 15bc7ab957, 833dae6d26.
• Go 1.5 — Done: 888767fcc4, 5bb89eb009, e5a0d6399e, 4da157a723, a51d5f27e8, 1122836b5f, bb418a59f8 (approximate float formatting in errors), 13485be939, 71080fbb9e, 99475dfb59 (spurious div-zero errors).
• Go 1.6 — Done: 85de30e72f, c396c047c6 (remove restriction on float exponent parsing), 76285213b8, 79a3b561b5, ddbc802b07, 2c11164db5, 715f63778d, 732e2cd746, 50fa646776.
• Go 1.7 — Done: d3253876f2, 07749aef98, 97360096e5, 35dd2ed58d (rename mparith files), f32161daf8 (one new Node per defaultlit: Unicode compile alloc −5.8%).

Static initialization, composite literals and init

Span: Go 1.1 → Go 1.9 · Status at go1.17: sinit.go model with static data, dynamic init and oaslit; extended later with staticinit → continues as Static initialization and package init (1.18+)

Continues in: Package initialization order, static initialisation and init functions (Go 1.10 → Go 1.17)

Earlier history: Initialization and static data (Go 1.0 → Go 1.0) · Composite literals (Go 1.0 → Go 1.0)

Design. sinit decides, per top-level var x = expr, whether the initializer can be laid out as static data (staticassign) or needs init-time code (anylit/fixedlit/maplit). Go 1.1 skipped codegen for var _ = ... when unneeded (6592456feb) and computed initialization order for blank vars (880d869764, 1.2). e5c105033a (1.3) fixed an unsound optimisation: var y = x; var x int was treated as x = 0, wrong when x is defined in C/assembly (cgo), so propagation is disabled when x has no Go initializer. Go 1.4 stopped using static init for small structs/fields (cfafa9f4cb). Go 1.5 resolved &x.f at link time (2fc29a83ae), statically initialised function pointers (632217aae4, go tool text segment −7.4 kB), and unsafe.Pointer(&x) of a global (9f90f31c3a). Go 1.6 statically initialised captureless closures (4f97ec0866), fixed initialization logic (aaabe3d849). Go 1.7 reordered slicelit to fill the stack array before slicing it (934c359964, so no write barriers; binaries ~1% smaller), treated static composite literals as side-effect free (55ab07c224) and eliminated a copy for static literals (b024ed0d94), CSE learned that newobject is bespoke (db5338f879: issue 15235 size 10k compile 44.9 s → 7.7 s). Go 1.8 added OSLICELIT and unified arraylit/structlit (49cce1a62e, cd2d5ee048), statically initialised some interface values (dfc56a4cd3), two tables for table-driven map inserts (d98de0c3d0), size hints for map literal allocations (1faea596e4), OSTRUCTKEY (add3ff549a: Unicode allocs −13.7%) and bba1ac4fd9 (only explicit OKEY nodes). Go 1.9 fixed a missed write barrier for global = T{} (160914e33c, oaslit not for globals), unrolled small static maps with cutoff 25 (50688fcb6e: 15 min → 45 s on #19751), and for functions with more than 500 user inits builds a static array of functions and loops (d1b544c7eb).

Timeline.

• Go 1.1 — Done: 6592456feb, 2af3cbe308, 0b2ca9e62f.
• Go 1.3 — Done: e5c105033a, 8a2db409c4.
• Go 1.4 — Done: cfafa9f4cb, 3c40ee0fe0 (simplify explicit zeroing).
• Go 1.5 — Done: 2fc29a83ae, 632217aae4, 9f90f31c3a, 0c9f3e4972, fa1ea497d5/1125cd4997 (func value symbols at declaration).
• Go 1.6 — Done: 4f97ec0866, aaabe3d849, 1ca7a64a0d.
• Go 1.7 — Done: 934c359964, 55ab07c224, b024ed0d94, 3c6e60c0e4, f973e79d09/7971864267/4e75932cf7 sinit cleanups, f3575a9561.
• Go 1.8 — Done: 49cce1a62e, cd2d5ee048, 7b5df0c195, db9796dac5, dfc56a4cd3, d98de0c3d0, 1faea596e4, add3ff549a, bba1ac4fd9, 64214792e2, 749720a036, 41d2278eef, df2b63f09b.
• Go 1.9 — Done: 160914e33c, 50688fcb6e, d1b544c7eb, a73a330cdf (count init functions from 0), 49a533e212, 6ee8c6a7ce, 095a62c349, 3237af2da8.

Walk-level lowering and runtime-call optimisations

Span: Go 1.1 → Go 1.9 · Status at go1.17: still the walk/order model; the runtime entry points mostly persist → continues as Static initialization and package init (1.18+)

Continues in: Lowering in order/walk and the shape of runtime calls emitted by the frontend (Go 1.10 → Go 1.17)

Design. Many compiler changes in this era moved decisions from the runtime to compile time, as walk.c/order.c rewrites to cheaper runtime calls. Interface conversion: convT2I cache (18e86644a3, BenchmarkConvT2ISmall 43→15 ns), inline pointer-sized convT2I (8fd65b0e1d), iface==concrete without allocation as x, ok := i.(C); ok && x == c (77a2113925, 38 std sites, ~75% faster), calls by reference (deb554934c), non-variadic assertI2T (ccdb50931f), inline x := y.(*T) (4224d81fae), scalar x, ok := y.(T) (615a52b95b, fmt printArg 3952→2624 bytes), itabs emitted by the compiler (f00bbd5f81) so remaining convT2I get the itab directly (859b63cc09), inline convT2E/convT2I when result does not escape (6129f37367), inline convI2E (395d36a67d), specialised convT2E16/32/64/string/slice/noptr and zero-value no-alloc (504bc3ed24, 93% of calls), efaceeq/ifaceeq simplification (e67d881bc3), CONV rather than CONVNOP for interface conversions (807c80fce3), canonical empty interfaces (62947bedd2). Maps and strings: []byte key lookup without copy (f5f5a8b620), mapassign returns a pointer to the slot so m[k] = v is *mapassign(t, m, &k) = v (442de98c14, preparation for m[k] += v in one call), mapassign_fast* and mapdelete_fast* (ec091b6af2, 5d6b7fcaa1, int32/int64/string keys, ~30% faster assigns), string range (0dae9dfb08, ASCII fast path 43.7→10.3 ns), runtime string ops written in Go (61dca94e10 with go:nosplit), makeslice with int arguments (e6f9f39ce5), growslice using int (81d4072eb0) and removing growslice_n (d1341d6cf3), vararg runtime calls removed (24699fb05c, 6f6a9445c9). Loop and arithmetic: memclr idiom recognition for for i := range a { a[i] = zero } (f03c9202c4, 18 std places; 64-byte clear 50.8→4.1 ns), single-comparison integer in-range checks (6286188986) extended to switch cases (8c85e23087, “min range size 2”), samesafeexpr extensions for m[k] op= v (9d2b988e4a, 9d4623fe43), constant switch cases tracked in a map (e26499153e), explicit zero-divide panic (18559e2da7), faulting arguments computed before argument stores (cf28e5cc9d), panicwrap argument-free (2c91bb4c8a), loop rescheduling by stack bound via FORUNTIL (d71f36b5aa), unsafe builtins handled as universal builtins (3f2cb493e5).

Timeline.

• Go 1.1 — Done: 18e86644a3, 8fd65b0e1d, d098bffd84 (avoid copy on type assertion), 77f3e189d2 faster string equality, 1d6eb2e9fa/2ad57b4583 (hash/eq ignore padding and blank fields), c0b3c17184.
• Go 1.3 — Done: deb554934c, f5f5a8b620, d227d680ec ([]byte("string") 100x less memory), 6f6a9445c9, 24699fb05c.
• Go 1.4 — Done: 61dca94e10, 4af796fb6e (runtime.hex printing type).
• Go 1.5 — Done: 77a2113925, ccdb50931f, f03c9202c4, 4224d81fae, 1d4bfb3ebb, 81d4072eb0, f5b8813e93; 32fddadd98 (runtime: slice growth reduced to 2x), 6f07ac2f28 (pad structs ending in zero-sized fields), dbe9ab69d9.
• Go 1.6 — Done: eddd7ff3cd, bca70a66a7.
• Go 1.7 — Done: f00bbd5f81, 859b63cc09, 4cef0e980a/bc8458ab02/36694064e5 (no algs for [0]T and [1]T, && in generated eq), d0c11577b9, 0f5d78f678, 92bf58c238, b30e1d728c alg-generation cleanups, 8ffe496ae7 fewer algorithm kinds, d1341d6cf3.
• Go 1.8 — Done: 6286188986, 8c85e23087, 615a52b95b, 9d2b988e4a, 9d4623fe43, e26499153e, e6f9f39ce5, 0dae9dfb08, 6129f37367, 395d36a67d, 442de98c14, cf28e5cc9d, 3f2cb493e5, ca5cea9dca, 27eebbabc2 (remove throwreturn).
• Go 1.9 — Done: 504bc3ed24, e67d881bc3, ec091b6af2, 5d6b7fcaa1, d71f36b5aa, 2c91bb4c8a, 807c80fce3, 62947bedd2, febafe60d4, dbd51ce99c (intrinsify math.Sqrt), a0d6d3855f (typename in walk), d8899acaf8.

Write barriers, precise stacks and liveness (compiler side)

Span: Go 1.2 → Go 1.7 · Status at go1.17: write-barrier insertion moved into SSA later; frontend marks (pragmas, OASWB) removed in 1.9 → continues as Old typechecker and IR node-model cleanup (1.18+)

Design. For the concurrent GC, the compiler had to supply precise pointer maps and, later, write barriers. The compiler-side steps were: precise stack-frame liveness (precisestack, disabled for 1.2 in 30ecb4cd05: “the zeroing required without it is too expensive”, re-enable by GOEXPERIMENT=precisestack; enabled by default in 1.3 by ecf700b5ee, reverted/relanded as 53061193f1 after a 32-bit fix, costing about 5% of all.bash time and tracked as issue 7345); this guarantees interface values are always initialised so the type word is trustworthy. Cost reduction followed in 1.3: shorter temporary lifetimes through orderexpr-allocated temporaries with VARKILL (daca06f2e3, 96d90d0981: ambiguously live temps in godoc 860 → 711 → 121 → 23), and compact liveness bitmaps (4676fae525: one bitmap length per set, duplicate bitmaps merged, bitmap sets named gclocals.<md5> and dupok so the linker dedups; bitmap bytes in godoc 1326600 → 245580, binary −9%). Liveness got 10x faster in 1.4 (7aa3031eba). Go 1.4 emitted write barriers (fcb4cabba4: *p = x becomes runtime.writebarrierptr(p,x); “the goal is to slow things down (and be correct)”, BinaryTree17 +10.7%), with 2/3/4-word specialisations (a3416cf5cd), elision for *x = T{}-style zeroing (3c40ee0fe0) and for x = x[0:y]/x = append(x, ...) (1552e62d70); the interface representation changed so that the data word holds only pointers (950ad4fa2b, 75b72b1b27 re-enabled IfacePointerOnly). In 1.5 barriers are emitted “at lower level” (0ad4f8b1f7, preparation for inlining), with the writeBarrierEnabled check inlined (653d56075d), no barrier for *tmp when tmp=&PAUTO (a7bb393628), a barrier in copy of function parameters to heap (e5ef657264), //go:nowritebarrier (557a61d270). Go 1.6 added go:nowritebarrierrec (3a765430c1, special-case allocm 402e37d4a9), 1.8 added go:yeswritebarrierrec (a9e6cebde2) and go:notinheap (77527a316b): no new(T), make([]T), append, or implicit allocation of a notinheap T, propagated to structs/arrays containing them, so stores to pointers to such types need no barrier. Go 1.7 removed PHEAP bits (b6dc3e6f66: new PAUTOHEAP pseudo-class, walkexpr rewrites references to indirections of a stack PAUTO), so liveness and the SSA back end see ordinary variables.

Timeline.

• Go 1.2 — Done: 30ecb4cd05 precisestack off by default; f91e682cca shorter bitmaps. Left open: call-site pointer bitmaps “not ready in time”.
• Go 1.3 — Done: ecf700b5ee, 53061193f1, daca06f2e3, 96d90d0981, 4676fae525, 8bd8cede03 (-live flag). Left open: issues 7343, 7344 (GC bugs) and 7345 (cost); 23 temps remain ambiguously live.
• Go 1.4 — Done: fcb4cabba4, a3416cf5cd, 3c40ee0fe0, 1552e62d70, 950ad4fa2b, 75b72b1b27, 7aa3031eba. Left open: elision of x = x[0:y] and append is a 1.4-only simplification; “for Go 1.5, will need to change the compilation” (1552e62d70).
• Go 1.5 — Done: 0ad4f8b1f7, 653d56075d, a7bb393628, e5ef657264, 557a61d270, 2050f57141; 08e25fc1ba //go:systemstack, 19b8aa3b5d (OASWB name).
• Go 1.6 — Done: 3a765430c1, 402e37d4a9, dac87e9ed3 (systemstack only in runtime).
• Go 1.7 — Done: b6dc3e6f66, dec1bae916, d25c3eadea.
• Go 1.8 — Done: a9e6cebde2, 77527a316b.
• Go 1.9 — Done: bdb9b945b9 OASWB eliminated, d71f36b5aa, c96e94e69d^1.8 etc. (see other).

Compiler data structures: Node, Nodes, Type, and the types package

Span: Go 1.5 → Go 1.9 · Status at go1.17: ir.Node and types.Type as separate packages came in later releases; the 1.9 types package is the start → continues as Types package internals: size, algorithm kind, TFlag, SIMD flags (1.18+)

Continues in: dev.regabi: from *Node struct to the ir.Node interface and concrete node types (Go 1.10 → Go 1.17)

Design. The Go-port compiler spent two years reshaping its main data structures, mostly with toolstash -cmp as the correctness bar. Lists: NodeList linked lists were first replaced by slices in specific places (1.6), then Ian Lance Taylor built a transitional nodeSeq interface (466c948b55, “I tried to write a program to convert *NodeList to Node, but ran into too many problem cases”) and converted package by package (ca56c590d4, 2aa2da295f, 132ebeac3f, 99b6b77e22, 55c65d4a97, 80e5b52566, 65c4b55aba, 72d90d8238, 2a68c6c27c, 6c4e90a99e, f444b8a80e, 72655afb4e removes NodeList), leaving Nodes (1d5001afef for Nbody and Func.Inl). Types: Type shed linked Down/Type tricks: TFIELD types became a separate Field type (2e9369067b, c278f9302e), Type.Fields became a Fields type (517b6131b2, 0d2e92c2ca, 1c2bdfb7d9), Func.Inldcl, In/Out/This tuples were removed (c837761b52, dbed1c6361), constructors typArray, typSlice, typChan, typPtr, typMap encapsulated fields (eb98e51563, 09c672d50a, fdf6761e01, 76e72691a0), TSLICE split from TARRAY (40f1d0ca9f), and f38f43d029 “shrink gc.Type in half” by moving etype-specific fields into auxiliary types reached via Extra (alloc −2% to −3.4%, +1% allocs). Node shape: ODOT stores its selector in Sym instead of an allocated ONAME Right (5f525ca60d: 5000 fewer newname calls, 6.6% fewer nodes), OSTRUCTKEY and implicit OKEY removal (see literals), ODCLFIELD without Name/Param (dc46b882d5) and constructing Fields directly when importing (d553c29dc1), 166b1219b8 allocating Name/Param/Func together with Node (allocs −5%), ed70f37e73 packing bool fields into bitsets (alloc −2.4 to −4.1%), then Node.Class, Typecheck, Initorder, Embedded, Walkdef, hasVal, Likely into flags (386765afdf, 502a03ffcf, e2560ace3c, af7da9a53b, d286399641, 2fb2ebc32e, 7f0757b394), Ullman→HasCall (870d079c76), Sym flags as bitset8 (a5a1fd4bc9, b2c391b70c) and Used moved to Name (fc08a19cef). The big structural split came in f68f292820 (2017-04-04): “factor out Pkg, Sym, and Type into package types”, creating cmd/compile/internal/types with a types/utils.go of hooks and two conversion functions between *gc.Node and a dummy types.Node to break cycles; follow-ups moved the dcl stack (fd44d872de, 48163968b2), typepkg (24c52ee570), unexported Nopkg/PkgMap (62a2bee7a5, 39a132cb2f), removed Sym.Link, FieldName, IterFields and Cmptmp (1368977a08, 5280dfbfad, 5b38923eba, 3158583713). Type caching: pointer/slice types are cached (78a267e379: stack slot reuse relies on Type identity), disabled in the back end (f9fb4579e1) for concurrency, with 2805d20689 replacing ptrto by typPtr. Haspointers caches were removed (944d56d763, e82c925f5e) and dowidth ran more in the front end (0b6a10ef24, 8dafdb1be1 WidthCalculated, c51559813f, b1b4f67169).

Timeline.

• Go 1.5 — Done: Node splits and field moves (see first thread), Val.U interface (13485be939), d970bea885 starts syntax.go for the syntax tree definitions, 96c91fa9db String methods, e64764c8d0 cache commonly used Ptrto types, 8b3670ffc6.
• Go 1.6 — Done: []*Node migrations (703bd83623, 22452ac592, dab0dac01a, 391cc54da8, bab01a0b4b, d5fe165ca0, a2119aca7d, b9dbb030d5, dd42eff8fe), bool conversions.
• Go 1.7 — Done: 466c948b55..72655afb4e, 6c4e90a99e, 52d9479e3b, 2e9369067b, 517b6131b2, f38f43d029, 5f525ca60d, 40f1d0ca9f, eb98e51563, 09c672d50a, e3c7497327 (typWrapper), fdf6761e01, 76e72691a0, 8640b51df8 (Type.Elem), 1624a9c9e7, 3efefd9395, e76fc1b921, 007b12977a (Maplineno out of Type), b83618f964 (Type.Nname), b2b5e779f5 (ignore receiver in Eqtype; moves receiver check into addmethod), 62e26e7511, b594b8b039, 1765863e57 (TypeList→slice), 34699bc7a8 (reduce **Node params: Template allocs −15.7%, Compiler −17.5%), 7e8e9abe0a, a4be24cbe6/edca4cda88/removing Nod(OXXX,...), 3621600c92 magic.go, 9d7b2b7b10 universe.go, 4720f49e18 relocate Type code, 11d916b157 (Node.Nointerface), e3a9dca7cc, 3da1a26fba (‘any’ no longer leaks into user package); 1220ac27ce, 68c86a0096. Left open: Type still lives in package gc.
• Go 1.8 — Done: 78a267e379, add3ff549a, dc46b882d5, d553c29dc1, bba1ac4fd9, 2b687a7df8 (interface methods not treated like functions), d89b70d433, 70d685dc72; 1fcad29341 (OREGISTER), a7c84668c8 (Label type removed), dc53ea7772 (IsHiddenClosure), dc5f9311be, f8a3444388 (EscScope), 3be166dc70, d58219e50b, 2b49d129c4, 41fa42b447, 82703f84e4/d7012ca282/584978f4b5/073d248bf5/fc47ee2332 (unexport helpers and globals), 42b37819a1 (mkbuiltin generates code), 3f2cb493e5.
• Go 1.9 — Done: f68f292820 (types package), fd44d872de, 24c52ee570, ed70f37e73, 386765afdf and the Node flags series, 166b1219b8, a5a1fd4bc9, b2c391b70c, 236ef852be (split SetInterface from SetFields), 07de3465be (recursive interfaces), b1b4f67169/8ee2d5bc00 (SetFields/Width safety), 944d56d763, e82c925f5e, efc47819c0/371aa23d10 (no Trecur), 0b6a10ef24, ecc6a81617, 3a89065c6c, 3c0072e056, 97b89dc055, fdef951116, 00f4cacb49. Left open: Node still carries every node kind (the commit message of 756b9ce3a5 says Phase 3 is “planned for eventual removal”).

Compiler performance, formatting and concurrency

Span: Go 1.7 → Go 1.9 · Status at go1.17: backend concurrency via -c, with cmd/go setting it; later default → continues as Compile-time performance, concurrency and the self-PGO’d compiler (1.18+)

Continues in: Concurrent compilation and frontend performance (Go 1.10 → Go 1.17)

Design. Compile time was tracked by compilebench (Template, Unicode, GoTypes, Compiler, MakeBash). In 1.7 ad4c55c076 replaced fmt.Sprintf with concatenation, 65b4020403 stopped creating 2 Syms and 2 Nodes per string, 135109d241 reduced slice-header allocation for :=. In 1.8 f542576b9e added compiler phase timing (-bench flag writing benchmark-format records like BenchmarkCompile:go/types:fe:parse), 6e759ad2e2 added runtime/trace support, and the fmt.go printing layer was reworked: a printer experiment (dc2a0d59a2, f7ac5da495, allocations up 10%) was abandoned in favour of fmt.Formatter/fmt.State for *Node, Op, Val, *Type, *Sym, Nodes (adcd34c732, 9e1f6a326e, 97ba3c8242, 8d0bbe2b48, a0d2010208, 266c6223df, 0ca5f269d4 removes the printer), then 37d452c3e9/0cd3ecb016 brought allocations back below the pre-change level for issue 16897 (reflect.go uses the plain tconv string method). In 1.9 723ba180b3 removed the fmtmode and fmtpkgpfx globals (they “stand in the way of making the compiler more concurrent”) by encoding the mode as named types (fmtNodeErr, fmtNodeDbg, fmtNodeTypeId), after weighing and rejecting struct wrappers (allocate on interface conversion), %*v precision, fmt.State context and a full rewrite; efc47819c0 threads a recursion depth instead of Trecur. Then 756b9ce3a5 (2017-03-19) added the initial backend concurrency: phases 5–8 (SSA, lowering, genssa, assembly) run per function in parallel using -c; order/walk proved hard to make safe, so with c>1 all functions finish phase 4 before any later phase starts, auto-generated functions (wrappers, eq/hash) after the first batch are compiled serially, and c=1 has no goroutines at all so cmd/go could “simply have cmd/go set c=1 always” if problems appear. A handful of mutexes were added; supporting changes: disabling typPtr caching in the backend (f9fb4579e1), per-function autotmp numbering (b87fcc6e06), typenamesym not touching Sym.Def and signatlist as a map sorted for reproducibility (91433eb577 reverted to 6d9c77f5dd after non-deterministic builds #19872), liveness variable indices in a map instead of Node.Opt (794d29a46f), 61336b78c1, -d compilelater, f5c878e030 randomised compile order under the race detector, 0b6a10ef24. Other perf commits: 302474c61c disable memprofile when unused, da67c23fbb flag to disable DWARF (−2.8% alloc), d62c6c3c39, f8b0231639 always optimise when building the runtime, 22f1b56dab -c flag, 8eb14e9de5 string debug flags, f9be63b9ba -d help listing keys.

Timeline.

• Go 1.7 — Done: ad4c55c076, 65b4020403, 135109d241, d447613875, 0373128318, 1a9373bc57, ea5091fcd7, f32161daf8.
• Go 1.8 — Done: f542576b9e, 6e759ad2e2, adcd34c732 and the Formatter series, 37d452c3e9, 0cd3ecb016, 2b5c18c99e, 09686a5873; 37d452c3e9.
• Go 1.9 — Done: 723ba180b3, 756b9ce3a5, f9fb4579e1, b87fcc6e06, 6d9c77f5dd, 794d29a46f, 61336b78c1, 302474c61c, da67c23fbb, f5c878e030, 22f1b56dab, 98b3e3a064 (match tool versions), f8b0231639. Left open: “Concurrent backend compilation still defaults to off”; “In future work, cmd/go will automatically set -c”; order and walk remain serial; some mutexes “may still be eliminable”.

Pragmas, directives and compiler flags

Span: Go 1.1 → Go 1.9 · Status at go1.17: //go: pragma set persisted and grew → continues as Compiler debugging infrastructure: bisect/hash debugging, flags, dumps (1.18+)

Continues in: Directives and pragmas in the frontend (//go: handling) (Go 1.10 → Go 1.17)

Design. Pragmas are recognised in the lexer (then in noder): //go:noescape for extern funcs (fd178d6a7e, 1.1), //go:nosplit and //go:linkname, //go:cgo_* (fd2bc95d53, 1.5; linkname requires import "unsafe"), //go:nowritebarrier (557a61d270), //go:systemstack (08e25fc1ba, restricted to runtime by dac87e9ed3), //go:noinline (a92543e1a1), //go:nowritebarrierrec (3a765430c1), //go:yeswritebarrierrec (a9e6cebde2), //go:notinheap (77527a316b). pragmas tracked in the lexer (3c0fae5306), handled immediately by noder (ee161e8591, 55875977eb), with bad combinations reported earlier (5f5d882f5c), and directives must start the line (d390283ff4). Flags: -pack (b022334029), -live (8bd8cede03), -d accepting comma-separated name=value lists (6c328efc4c), unknown -d flag aborts (516d9ef53b), -d disablenil (01512b3edb), -importmap (7bcc6a1615), -buildid (0f6da8923f), -memprofilerate (00d4a6b35d), new flag syntax (8a072ada84, d5ff441d9a), -msan (0c69f1303f), -linkobj (feb6131b1a), -dolinkobj (005c77dde8), -importcfg (4d6b08de70, “a generalization of and supersedes -importmap, -importsuffix, and -I”), -C, -c, -bench, -d help, -d compilelater, -trimpath documented (f2eb3de636), -A removed (832082b44e). Position-independent code for -buildmode=c-shared on arm (876b7cc227) and -buildmode=shared on linux/386 and arm (3ae4dc8a75, 78c05b8657) were small compiler pieces.

Timeline.

• Go 1.1 — Done: user-visible fd178d6a7e noescape; 041fc8bf96 race instrumentation -b; 80dbe74360 go.weak symbol prefix.
• Go 1.3 — Done: user-visible b022334029 -pack, 8bd8cede03 -live.
• Go 1.4 — Done: 516d9ef53b.
• Go 1.5 — Done: user-visible fd2bc95d53, 557a61d270, 08e25fc1ba, 7bcc6a1615, 6c328efc4c, 0f6da8923f, 01512b3edb.
• Go 1.6 — Done: user-visible a92543e1a1, 3a765430c1, 0c69f1303f, dac87e9ed3, 876b7cc227, 3ae4dc8a75, 78c05b8657.
• Go 1.7 — Done: feb6131b1a, 3c0fae5306.
• Go 1.8 — Done: a9e6cebde2, 77527a316b, 832082b44e, 49b2dd583b (remove legacy debug flags).
• Go 1.9 — Done: user-visible 4d6b08de70, 005c77dde8, 22f1b56dab, 2a5cf48f91’s -C, f9be63b9ba, da67c23fbb, 98b3e3a064, 3c1914fc46 (distinguish .a and .o by content).

Race detector and sanitizer instrumentation in the frontend

Span: Go 1.1 → Go 1.7 · Status at go1.17: racewalk pass (later instrument) → continues as Compiler debugging infrastructure: bisect/hash debugging, flags, dumps (1.18+)

Continues in: checkptr instrumentation and compiler debugging flags (Go 1.12 → Go 1.17)

Design. racewalk.c walks the typechecked AST and inserts calls to the race runtime around memory accesses. It arrived in Go 1.1 (041fc8bf96, 431 lines, enabled by -b), with PC passed directly to racefuncenter (ce287933d6, encoding/json race benchmark ~1.9x faster) and &&/|| instrumented (c0b3c17184). Go 1.2 fixed tail-call wrappers (e440354c40, 269b2f2d4d) and arrays (3be794cdc2). Go 1.6 generalised racewalk to instrument for other tools (9e902f0f3a) and added -msan (0c69f1303f); Go 1.7 made insertion careful (c3b3e7b4ef) and Go 1.9 randomised compile order when race-enabled (f5c878e030).

Timeline.

• Go 1.1 — Done: user-visible 041fc8bf96, ce287933d6, c0b3c17184.
• Go 1.2 — Done: e440354c40, 3be794cdc2, 269b2f2d4d.
• Go 1.6 — Done: user-visible 9e902f0f3a, 0c69f1303f.
• Go 1.7 — Done: c3b3e7b4ef.

Diagnostics and error messages

Span: Go 1.1 → Go 1.9 · Status at go1.17: ongoing; types2 later supplies messages → continues as Error reporting: codes, messages, and sub-errors (1.18+)

Earlier history: Diagnostics, error recovery and compiler plumbing (Go 1.0 → Go 1.0)

Design. A continuous stream of message-quality work: replacing “typechecking loop” with real diagnostics (892fa3ae6c, 6363fc5aa6), better line numbers (bf59aafddc composite literals, dd166b9437 “no new variables”, e2711cb202), removal of the word “ideal” (703bd83623-era: 703b897f78), “have/want” signatures for argument and return count errors (2d573eee8a, ec5b6406b7, 19d2061d50 suppress when types unknown), interface satisfaction messages (2254785c3e, 574e0f9a48, 1c2021ca14 suggests *T), unknown-field message (7b4545653c), import errors (d06dcd4595, 8d530f2472, 85195e2ccf, 5be1821a31, 9fda4df9a0 deterministic), and in 1.9 duplicate-error suppression (d62c6c3c39, 3218b1aa6f, f62c608abb, d55f528826, 2e60882fc7), correct redeclaration position (d79bb78a71), assignment count mismatch messages (88cf932e98, 73a44f0456, 3c7a812485), init direct invocation (cb6e0639fb).

Timeline.

• Go 1.1 — Done: 892fa3ae6c, 6363fc5aa6, d06dcd4595, 1c2021ca14, a7a3fe7238 (oversized arrays), c208a3a263, bd0bb2bc39, 79a3b561b5^1.6… see other items.
• Go 1.2 — Done: 703b897f78, d00bd1d1f4, 2254785c3e, 8d530f2472.
• Go 1.3 — Done: a599b4890a, 1d2b71ce83, 656a402545, 574e0f9a48.

Changes in this slice that are not part of a thread are listed on the release pages: 1.1 · 1.2 · 1.3 · 1.4 · 1.5 · 1.6 · 1.7 · 1.8 · 1.9

Compiler frontend (Go 1.10–1.17)

Reader: Claude Sonnet. Cites 1,071 of 1,353 commits in this slice; every non-noise commit is cited, plus 30 larger commits the noise filter had set aside, which a separate gap reader described. Read the design-heavy messages, subject lines and a few full messages, and checked the -G/AllowGenerics behaviour against the go1.17 source. No diffs were read, so the typechecker, walk, inlining and types threads are thinner than the IR, export-data and generics threads.

dev.regabi: from *Node struct to the ir.Node interface and concrete node types