Commit 704374e51294e14285b0b54030c1cb6154868098 | zig

author	Andrew Kelley <andrew@ziglang.org> 2018-11-17 01:38:35-05:00
committer	Andrew Kelley <andrew@ziglang.org> 2018-11-17 01:38:35-05:00
log	704374e51294e14285b0b54030c1cb6154868098
tree	a0e33d754ab4b5fe84961a48711cdeff23dc858b
parent	38629628814aae6ba09bc2c25fdbac407a5d9e17
signature	Commit is signed but in an unrecognized format.

rename `section` keyword to `linksection`

add zig fmt support for this syntax

closes #1152

11 files changed, 314 insertions(+), 240 deletions(-)

doc
- docgen.zig
- langref.html.in
src
std
- zig
test
- compile_errors.zig

doc/docgen.zig+1-1

...	...	@@ -764,7 +764,7 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: var, source_token: Tok
764	764	std.zig.Token.Id.Keyword_pub,
765	765	std.zig.Token.Id.Keyword_resume,
766	766	std.zig.Token.Id.Keyword_return,
767		std.zig.Token.Id.Keyword_section,
	767	std.zig.Token.Id.Keyword_linksection,
768	768	std.zig.Token.Id.Keyword_stdcallcc,
769	769	std.zig.Token.Id.Keyword_struct,
770	770	std.zig.Token.Id.Keyword_suspend,

doc/langref.html.in+221-223

...	...	@@ -7713,36 +7713,35 @@ fn readU32Be() u32 {}
7713	7713	<p>For some discussion on the rationale behind these design decisions, see <a href="https://github.com/ziglang/zig/issues/663">issue #663</a></p>
7714	7714	{#header_close#}
7715	7715	{#header_open\|Grammar#}
7716		<pre><code class="nohighlight">
7717		Root <- skip ContainerMembers eof
	7716	<pre><code>Root <- skip ContainerMembers eof
7718	7717
7719	7718	# * Top level *
7720	7719	ContainerMembers
7721		<- TestDecl ContainerMembers
	7720	<- TestDecl ContainerMembers
7722	7721	/ TopLevelComptime ContainerMembers
7723	7722	/ KEYWORD_pub? TopLevelDecl ContainerMembers
7724	7723	/ KEYWORD_pub? ContainerField COMMA ContainerMembers
7725	7724	/ KEYWORD_pub? ContainerField
7726	7725	/
7727	7726
7728		TestDecl <- KEYWORD_test STRINGLITERAL Block
	7727	TestDecl <- KEYWORD_test STRINGLITERAL Block
7729	7728
7730		TopLevelComptime <- KEYWORD_comptime BlockExpr
	7729	TopLevelComptime <- KEYWORD_comptime BlockExpr
7731	7730
7732	7731	TopLevelDecl
7733		<- (KEYWORD_export / KEYWORD_extern STRINGLITERAL? / KEYWORD_inline)? FnProto (SEMICOLON / Block)
	7732	<- (KEYWORD_export / KEYWORD_extern STRINGLITERAL? / KEYWORD_inline)? FnProto (SEMICOLON / Block)
7734	7733	/ (KEYWORD_export / KEYWORD_extern STRINGLITERAL?)? VarDecl
7735	7734	/ KEYWORD_use Expr SEMICOLON
7736	7735
7737		FnProto <- FnCC? KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? Section? EXCLAMATIONMARK? (KEYWORD_var / TypeExpr)
	7736	FnProto <- FnCC? KEYWORD_fn IDENTIFIER? LPAREN ParamDeclList RPAREN ByteAlign? LinkSection? EXCLAMATIONMARK? (KEYWORD_var / TypeExpr)
7738	7737
7739		VarDecl <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? Section? (EQUAL Expr)? SEMICOLON
	7738	VarDecl <- (KEYWORD_const / KEYWORD_var) IDENTIFIER (COLON TypeExpr)? ByteAlign? LinkSection? (EQUAL Expr)? SEMICOLON
7740	7739
7741		ContainerField <- IDENTIFIER (COLON TypeExpr)? (EQUAL Expr)?
	7740	ContainerField <- IDENTIFIER (COLON TypeExpr)? (EQUAL Expr)?
7742	7741
7743	7742	# * Block Level *
7744	7743	Statement
7745		<- KEYWORD_comptime? VarDecl
	7744	<- KEYWORD_comptime? VarDecl
7746	7745	/ KEYWORD_comptime BlockExprStatement
7747	7746	/ KEYWORD_suspend (SEMICOLON / BlockExprStatement)
7748	7747	/ KEYWORD_defer BlockExprStatement
...	...	@@ -7753,50 +7752,50 @@ Statement
7753	7752	/ AssignExpr SEMICOLON
7754	7753
7755	7754	IfStatement
7756		<- IfPrefix BlockExpr ( KEYWORD_else Payload? Statement )?
	7755	<- IfPrefix BlockExpr ( KEYWORD_else Payload? Statement )?
7757	7756	/ IfPrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
7758	7757
7759		LabeledStatement <- BlockLabel? (Block / LoopStatement)
	7758	LabeledStatement <- BlockLabel? (Block / LoopStatement)
7760	7759
7761		LoopStatement <- KEYWORD_inline? (ForStatement / WhileStatement)
	7760	LoopStatement <- KEYWORD_inline? (ForStatement / WhileStatement)
7762	7761
7763	7762	ForStatement
7764		<- ForPrefix BlockExpr ( KEYWORD_else Statement )?
	7763	<- ForPrefix BlockExpr ( KEYWORD_else Statement )?
7765	7764	/ ForPrefix AssignExpr ( SEMICOLON / KEYWORD_else Statement )
7766	7765
7767	7766	WhileStatement
7768		<- WhilePrefix BlockExpr ( KEYWORD_else Payload? Statement )?
	7767	<- WhilePrefix BlockExpr ( KEYWORD_else Payload? Statement )?
7769	7768	/ WhilePrefix AssignExpr ( SEMICOLON / KEYWORD_else Payload? Statement )
7770	7769
7771	7770	BlockExprStatement
7772		<- BlockExpr
	7771	<- BlockExpr
7773	7772	/ AssignExpr SEMICOLON
7774	7773
7775		BlockExpr <- BlockLabel? Block
	7774	BlockExpr <- BlockLabel? Block
7776	7775
7777	7776	# * Expression Level *
7778		AssignExpr <- Expr (AssignOp Expr)?
	7777	AssignExpr <- Expr (AssignOp Expr)?
7779	7778
7780		Expr <- KEYWORD_try* BoolOrExpr
	7779	Expr <- KEYWORD_try* BoolOrExpr
7781	7780
7782		BoolOrExpr <- BoolAndExpr (KEYWORD_or BoolAndExpr)*
	7781	BoolOrExpr <- BoolAndExpr (KEYWORD_or BoolAndExpr)*
7783	7782
7784		BoolAndExpr <- CompareExpr (KEYWORD_and CompareExpr)*
	7783	BoolAndExpr <- CompareExpr (KEYWORD_and CompareExpr)*
7785	7784
7786		CompareExpr <- BitwiseExpr (CompareOp BitwiseExpr)?
	7785	CompareExpr <- BitwiseExpr (CompareOp BitwiseExpr)?
7787	7786
7788		BitwiseExpr <- BitShiftExpr (BitwiseOp BitShiftExpr)*
	7787	BitwiseExpr <- BitShiftExpr (BitwiseOp BitShiftExpr)*
7789	7788
7790		BitShiftExpr <- AdditionExpr (BitShiftOp AdditionExpr)*
	7789	BitShiftExpr <- AdditionExpr (BitShiftOp AdditionExpr)*
7791	7790
7792		AdditionExpr <- MultiplyExpr (AdditionOp MultiplyExpr)*
	7791	AdditionExpr <- MultiplyExpr (AdditionOp MultiplyExpr)*
7793	7792
7794		MultiplyExpr <- PrefixExpr (MultiplyOp PrefixExpr)*
	7793	MultiplyExpr <- PrefixExpr (MultiplyOp PrefixExpr)*
7795	7794
7796		PrefixExpr <- PrefixOp* PrimaryExpr
	7795	PrefixExpr <- PrefixOp* PrimaryExpr
7797	7796
7798	7797	PrimaryExpr
7799		<- AsmExpr
	7798	<- AsmExpr
7800	7799	/ IfExpr
7801	7800	/ KEYWORD_break BreakLabel? Expr?
7802	7801	/ KEYWORD_cancel Expr
...	...	@@ -7807,35 +7806,35 @@ PrimaryExpr
7807	7806	/ LabeledExpr
7808	7807	/ CurlySuffixExpr
7809	7808
7810		IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr)?
	7809	IfExpr <- IfPrefix Expr (KEYWORD_else Payload? Expr)?
7811	7810
7812		LabeledExpr <- BlockLabel? (Block / LoopExpr)
	7811	LabeledExpr <- BlockLabel? (Block / LoopExpr)
7813	7812
7814		Block <- LBRACE Statement* RBRACE
	7813	Block <- LBRACE Statement* RBRACE
7815	7814
7816		LoopExpr <- KEYWORD_inline? (ForExpr / WhileExpr)
	7815	LoopExpr <- KEYWORD_inline? (ForExpr / WhileExpr)
7817	7816
7818		ForExpr <- ForPrefix Expr (KEYWORD_else Expr)?
	7817	ForExpr <- ForPrefix Expr (KEYWORD_else Expr)?
7819	7818
7820		WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)?
	7819	WhileExpr <- WhilePrefix Expr (KEYWORD_else Payload? Expr)?
7821	7820
7822		CurlySuffixExpr <- TypeExpr InitList?
	7821	CurlySuffixExpr <- TypeExpr InitList?
7823	7822
7824	7823	InitList
7825		<- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE
	7824	<- LBRACE FieldInit (COMMA FieldInit)* COMMA? RBRACE
7826	7825	/ LBRACE Expr (COMMA Expr)* COMMA? RBRACE
7827	7826	/ LBRACE RBRACE
7828	7827
7829		TypeExpr <- PrefixTypeOp* ErrorUnionExpr
	7828	TypeExpr <- PrefixTypeOp* ErrorUnionExpr
7830	7829
7831		ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr)?
	7830	ErrorUnionExpr <- SuffixExpr (EXCLAMATIONMARK TypeExpr)?
7832	7831
7833	7832	SuffixExpr
7834		<- AsyncPrefix PrimaryTypeExpr SuffixOp* FnCallArgumnets
	7833	<- AsyncPrefix PrimaryTypeExpr SuffixOp* FnCallArgumnets
7835	7834	/ PrimaryTypeExpr (SuffixOp / FnCallArgumnets)*
7836	7835
7837	7836	PrimaryTypeExpr
7838		<- BUILTININDENTIFIER FnCallArgumnets
	7837	<- BUILTININDENTIFIER FnCallArgumnets
7839	7838	/ CHAR_LITERAL
7840	7839	/ ContainerDecl
7841	7840	/ ErrorSetDecl
...	...	@@ -7858,91 +7857,91 @@ PrimaryTypeExpr
7858	7857	/ STRINGLITERAL
7859	7858	/ SwitchExpr
7860	7859
7861		ContainerDecl <- (KEYWORD_extern / KEYWORD_packed)? ContainerDeclAuto
	7860	ContainerDecl <- (KEYWORD_extern / KEYWORD_packed)? ContainerDeclAuto
7862	7861
7863		ErrorSetDecl <- KEYWORD_error LBRACE IdentifierList RBRACE
	7862	ErrorSetDecl <- KEYWORD_error LBRACE IdentifierList RBRACE
7864	7863
7865		GroupedExpr <- LPAREN Expr RPAREN
	7864	GroupedExpr <- LPAREN Expr RPAREN
7866	7865
7867		IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
	7866	IfTypeExpr <- IfPrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
7868	7867
7869	7868	LabeledTypeExpr
7870		<- BlockLabel Block
	7869	<- BlockLabel Block
7871	7870	/ BlockLabel? LoopTypeExpr
7872	7871
7873		LoopTypeExpr <- KEYWORD_inline? (ForTypeExpr / WhileTypeExpr)
	7872	LoopTypeExpr <- KEYWORD_inline? (ForTypeExpr / WhileTypeExpr)
7874	7873
7875		ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr)?
	7874	ForTypeExpr <- ForPrefix TypeExpr (KEYWORD_else TypeExpr)?
7876	7875
7877		WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
	7876	WhileTypeExpr <- WhilePrefix TypeExpr (KEYWORD_else Payload? TypeExpr)?
7878	7877
7879		SwitchExpr <- KEYWORD_switch LPAREN Expr RPAREN LBRACE SwitchProngList RBRACE
	7878	SwitchExpr <- KEYWORD_switch LPAREN Expr RPAREN LBRACE SwitchProngList RBRACE
7880	7879
7881	7880	# * Assembly *
7882		AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN STRINGLITERAL AsmOutput? RPAREN
	7881	AsmExpr <- KEYWORD_asm KEYWORD_volatile? LPAREN STRINGLITERAL AsmOutput? RPAREN
7883	7882
7884		AsmOutput <- COLON AsmOutputList AsmInput?
	7883	AsmOutput <- COLON AsmOutputList AsmInput?
7885	7884
7886		AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
	7885	AsmOutputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN (MINUSRARROW TypeExpr / IDENTIFIER) RPAREN
7887	7886
7888		AsmInput <- COLON AsmInputList AsmCloppers?
	7887	AsmInput <- COLON AsmInputList AsmCloppers?
7889	7888
7890		AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN Expr RPAREN
	7889	AsmInputItem <- LBRACKET IDENTIFIER RBRACKET STRINGLITERAL LPAREN Expr RPAREN
7891	7890
7892		AsmCloppers <- COLON StringList
	7891	AsmCloppers <- COLON StringList
7893	7892
7894	7893	# * Helper grammar *
7895		BreakLabel <- COLON IDENTIFIER
	7894	BreakLabel <- COLON IDENTIFIER
7896	7895
7897		BlockLabel <- IDENTIFIER COLON
	7896	BlockLabel <- IDENTIFIER COLON
7898	7897
7899		FieldInit <- DOT IDENTIFIER EQUAL Expr
	7898	FieldInit <- DOT IDENTIFIER EQUAL Expr
7900	7899
7901		WhileContinueExpr <- COLON LPAREN AssignExpr RPAREN
	7900	WhileContinueExpr <- COLON LPAREN AssignExpr RPAREN
7902	7901
7903		Section <- KEYWORD_section LPAREN Expr RPAREN
	7902	LinkSection <- KEYWORD_linksection LPAREN Expr RPAREN
7904	7903
7905	7904	# Fn specific
7906	7905	FnCC
7907		<- KEYWORD_nakedcc
	7906	<- KEYWORD_nakedcc
7908	7907	/ KEYWORD_stdcallcc
7909	7908	/ KEYWORD_extern
7910	7909	/ KEYWORD_async (LARROW TypeExpr RARROW)?
7911	7910
7912		ParamDecl <- (KEYWORD_noalias / KEYWORD_comptime)? (IDENTIFIER COLON)? ParamType
	7911	ParamDecl <- (KEYWORD_noalias / KEYWORD_comptime)? (IDENTIFIER COLON)? ParamType
7913	7912
7914	7913	ParamType
7915		<- KEYWORD_var
	7914	<- KEYWORD_var
7916	7915	/ DOT3
7917	7916	/ TypeExpr
7918	7917
7919	7918	# Control flow prefixes
7920		IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
	7919	IfPrefix <- KEYWORD_if LPAREN Expr RPAREN PtrPayload?
7921	7920
7922		WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
	7921	WhilePrefix <- KEYWORD_while LPAREN Expr RPAREN PtrPayload? WhileContinueExpr?
7923	7922
7924		ForPrefix <- KEYWORD_for LPAREN Expr RPAREN PtrIndexPayload
	7923	ForPrefix <- KEYWORD_for LPAREN Expr RPAREN PtrIndexPayload
7925	7924
7926	7925	# Payloads
7927		Payload <- PIPE IDENTIFIER PIPE
	7926	Payload <- PIPE IDENTIFIER PIPE
7928	7927
7929		PtrPayload <- PIPE ASTERISK? IDENTIFIER PIPE
	7928	PtrPayload <- PIPE ASTERISK? IDENTIFIER PIPE
7930	7929
7931		PtrIndexPayload <- PIPE ASTERISK? IDENTIFIER (COMMA IDENTIFIER)? PIPE
	7930	PtrIndexPayload <- PIPE ASTERISK? IDENTIFIER (COMMA IDENTIFIER)? PIPE
7932	7931
7933	7932
7934	7933	# Switch specific
7935		SwitchProng <- SwitchCase EQUALRARROW PtrPayload? AssignExpr
	7934	SwitchProng <- SwitchCase EQUALRARROW PtrPayload? AssignExpr
7936	7935
7937	7936	SwitchCase
7938		<- SwitchItem (COMMA SwitchItem)* COMMA?
	7937	<- SwitchItem (COMMA SwitchItem)* COMMA?
7939	7938	/ KEYWORD_else
7940	7939
7941		SwitchItem <- Expr (DOT3 Expr)?
	7940	SwitchItem <- Expr (DOT3 Expr)?
7942	7941
7943	7942	# Operators
7944	7943	AssignOp
7945		<- ASTERISKEQUAL
	7944	<- ASTERISKEQUAL
7946	7945	/ SLASHEQUAL
7947	7946	/ PERCENTEQUAL
7948	7947	/ PLUSEQUAL
...	...	@@ -7958,7 +7957,7 @@ AssignOp
7958	7957	/ EQUAL
7959	7958
7960	7959	CompareOp
7961		<- EQUALEQUAL
	7960	<- EQUALEQUAL
7962	7961	/ EXCLAMATIONMARKEQUAL
7963	7962	/ LARROW
7964	7963	/ RARROW
...	...	@@ -7966,25 +7965,25 @@ CompareOp
7966	7965	/ RARROWEQUAL
7967	7966
7968	7967	BitwiseOp
7969		<- AMPERSAND
	7968	<- AMPERSAND
7970	7969	/ CARET
7971	7970	/ PIPE
7972	7971	/ KEYWORD_orelse
7973	7972	/ KEYWORD_catch Payload?
7974	7973
7975	7974	BitShiftOp
7976		<- LARROW2
	7975	<- LARROW2
7977	7976	/ RARROW2
7978	7977
7979	7978	AdditionOp
7980		<- PLUS
	7979	<- PLUS
7981	7980	/ MINUS
7982	7981	/ PLUS2
7983	7982	/ PLUSPERCENT
7984	7983	/ MINUSPERCENT
7985	7984
7986	7985	MultiplyOp
7987		<- PIPE2
	7986	<- PIPE2
7988	7987	/ ASTERISK
7989	7988	/ SLASH
7990	7989	/ PERCENT
...	...	@@ -7992,7 +7991,7 @@ MultiplyOp
7992	7991	/ ASTERISKPERCENT
7993	7992
7994	7993	PrefixOp
7995		<- EXCLAMATIONMARK
	7994	<- EXCLAMATIONMARK
7996	7995	/ MINUS
7997	7996	/ TILDE
7998	7997	/ MINUSPERCENT
...	...	@@ -8001,77 +8000,77 @@ PrefixOp
8001	8000	/ KEYWORD_await
8002	8001
8003	8002	PrefixTypeOp
8004		<- QUESTIONMARK
	8003	<- QUESTIONMARK
8005	8004	/ KEYWORD_promise MINUSRARROW
8006	8005	/ ArrayTypeStart (ByteAlign / KEYWORD_const / KEYWORD_volatile)*
8007	8006	/ PtrTypeStart (KEYWORD_align LPAREN Expr (COLON INTEGER COLON INTEGER)? RPAREN / KEYWORD_const / KEYWORD_volatile)*
8008	8007
8009	8008	SuffixOp
8010		<- LBRACKET Expr (DOT2 Expr?)? RBRACKET
	8009	<- LBRACKET Expr (DOT2 Expr?)? RBRACKET
8011	8010	/ DOT IDENTIFIER
8012	8011	/ DOTASTERISK
8013	8012	/ DOTQUESTIONMARK
8014	8013
8015		AsyncPrefix <- KEYWORD_async (LARROW PrefixExpr RARROW)?
	8014	AsyncPrefix <- KEYWORD_async (LARROW PrefixExpr RARROW)?
8016	8015
8017		FnCallArgumnets <- LPAREN ExprList RPAREN
	8016	FnCallArgumnets <- LPAREN ExprList RPAREN
8018	8017
8019	8018	# Ptr specific
8020		ArrayTypeStart <- LBRACKET Expr? RBRACKET
	8019	ArrayTypeStart <- LBRACKET Expr? RBRACKET
8021	8020
8022	8021	PtrTypeStart
8023		<- ASTERISK
	8022	<- ASTERISK
8024	8023	/ ASTERISK2
8025	8024	/ LBRACKET ASTERISK RBRACKET
8026	8025
8027	8026	# ContainerDecl specific
8028		ContainerDeclAuto <- ContainerDeclType LBRACE ContainerMembers RBRACE
	8027	ContainerDeclAuto <- ContainerDeclType LBRACE ContainerMembers RBRACE
8029	8028
8030	8029	ContainerDeclType
8031		<- (KEYWORD_struct / KEYWORD_enum) (LPAREN Expr RPAREN)?
	8030	<- (KEYWORD_struct / KEYWORD_enum) (LPAREN Expr RPAREN)?
8032	8031	/ KEYWORD_union (LPAREN (KEYWORD_enum (LPAREN Expr RPAREN)? / Expr) RPAREN)?
8033	8032
8034	8033	# Alignment
8035		ByteAlign <- KEYWORD_align LPAREN Expr RPAREN
	8034	ByteAlign <- KEYWORD_align LPAREN Expr RPAREN
8036	8035
8037	8036	# Lists
8038		IdentifierList <- (IDENTIFIER COMMA)* IDENTIFIER?
	8037	IdentifierList <- (IDENTIFIER COMMA)* IDENTIFIER?
8039	8038
8040		SwitchProngList <- (SwitchProng COMMA)* SwitchProng?
	8039	SwitchProngList <- (SwitchProng COMMA)* SwitchProng?
8041	8040
8042		AsmOutputList <- (AsmOutputItem COMMA)* AsmOutputItem?
	8041	AsmOutputList <- (AsmOutputItem COMMA)* AsmOutputItem?
8043	8042
8044		AsmInputList <- (AsmInputItem COMMA)* AsmInputItem?
	8043	AsmInputList <- (AsmInputItem COMMA)* AsmInputItem?
8045	8044
8046		StringList <- (STRINGLITERAL COMMA)* STRINGLITERAL?
	8045	StringList <- (STRINGLITERAL COMMA)* STRINGLITERAL?
8047	8046
8048		ParamDeclList <- (ParamDecl COMMA)* ParamDecl?
	8047	ParamDeclList <- (ParamDecl COMMA)* ParamDecl?
8049	8048
8050		ExprList <- (Expr COMMA)* Expr?
	8049	ExprList <- (Expr COMMA)* Expr?
8051	8050
8052	8051	# * Tokens *
8053		eof <- !.
8054		hex <- [0-9a-fA-F]
	8052	eof <- !.
	8053	hex <- [0-9a-fA-F]
8055	8054	char_escape
8056		<- "\\x" hex hex
	8055	<- "\\x" hex hex
8057	8056	/ "\\u" hex hex hex hex
8058	8057	/ "\\U" hex hex hex hex hex hex
8059	8058	/ "\\" [nr\\t'"]
8060	8059	char_char
8061		<- char_escape
	8060	<- char_escape
8062	8061	/ [^\\'\n]
8063	8062	string_char
8064		<- char_escape
	8063	<- char_escape
8065	8064	/ [^\\"\n]
8066	8065
8067		line_comment <- '//'[^\n]*
8068		line_string <- ("\\\\" [^\n]* [ \n]*)+
8069		line_cstring <- ("c\\\\" [^\n]* [ \n]*)+
8070		skip <- ([ \n] / line_comment)*
	8066	line_comment <- '//'[^\n]*
	8067	line_string <- ("\\\\" [^\n]* [ \n]*)+
	8068	line_cstring <- ("c\\\\" [^\n]* [ \n]*)+
	8069	skip <- ([ \n] / line_comment)*
8071	8070
8072		CHAR_LITERAL <- "'" char_char "'" skip
	8071	CHAR_LITERAL <- "'" char_char "'" skip
8073	8072	FLOAT
8074		<- "0b" [01]+ "." [01]+ ([eE] [-+]? [01]+)? skip
	8073	<- "0b" [01]+ "." [01]+ ([eE] [-+]? [01]+)? skip
8075	8074	/ "0o" [0-7]+ "." [0-7]+ ([eE] [-+]? [0-7]+)? skip
8076	8075	/ "0x" hex+ "." hex+ ([pP] [-+]? hex+)? skip
8077	8076	/ [0-9]+ "." [0-9]+ ([eE] [-+]? [0-9]+)? skip
...	...	@@ -8080,128 +8079,128 @@ FLOAT
8080	8079	/ "0x" hex+ "."? [pP] [-+]? hex+ skip
8081	8080	/ [0-9]+ "."? [eE] [-+]? [0-9]+ skip
8082	8081	INTEGER
8083		<- "0b" [01]+ skip
	8082	<- "0b" [01]+ skip
8084	8083	/ "0o" [0-7]+ skip
8085	8084	/ "0x" hex+ skip
8086	8085	/ [0-9]+ skip
8087	8086	STRINGLITERAL
8088		<- "c"? "\"" string_char* "\"" skip
	8087	<- "c"? "\"" string_char* "\"" skip
8089	8088	/ line_string skip
8090	8089	/ line_cstring skip
8091	8090	IDENTIFIER
8092		<- !keyword ("c" !["\\] / [A-Zabd-z_]) [A-Za-z0-9_]* skip
	8091	<- !keyword ("c" !["\\] / [A-Zabd-z_]) [A-Za-z0-9_]* skip
8093	8092	/ "@\"" string_char* "\"" skip
8094		BUILTININDENTIFIER <- "@"[A-Za-z_][A-Za-z0-9_]* skip
8095
8096
8097		AMPERSAND <- '&' ![=] skip
8098		AMPERSANDEQUAL <- '&=' skip
8099		ASTERISK <- '' ![%=] skip
8100		ASTERISK2 <- '**' skip
8101		ASTERISKEQUAL <- '*=' skip
8102		ASTERISKPERCENT <- '*%' ![=] skip
8103		ASTERISKPERCENTEQUAL <- '*%=' skip
8104		CARET <- '^' ![=] skip
8105		CARETEQUAL <- '^=' skip
8106		COLON <- ':' skip
8107		COMMA <- ',' skip
8108		DOT <- '.' ![*.?] skip
8109		DOT2 <- '..' ![.] skip
8110		DOT3 <- '...' skip
8111		DOTASTERISK <- '.*' skip
8112		DOTQUESTIONMARK <- '.?' skip
8113		EQUAL <- '=' ![>=] skip
8114		EQUALEQUAL <- '==' skip
8115		EQUALRARROW <- '=>' skip
8116		EXCLAMATIONMARK <- '!' ![=] skip
8117		EXCLAMATIONMARKEQUAL <- '!=' skip
8118		LARROW <- '<' ![<=] skip
8119		LARROW2 <- '<<' ![=] skip
8120		LARROW2EQUAL <- '<<=' skip
8121		LARROWEQUAL <- '<=' skip
8122		LBRACE <- '{' skip
8123		LBRACKET <- '[' skip
8124		LPAREN <- '(' skip
8125		MINUS <- '-' ![%=>] skip
8126		MINUSEQUAL <- '-=' skip
8127		MINUSPERCENT <- '-%' ![=] skip
8128		MINUSPERCENTEQUAL <- '-%=' skip
8129		MINUSRARROW <- '->' skip
8130		PERCENT <- '%' ![=] skip
8131		PERCENTEQUAL <- '%=' skip
8132		PIPE <- '\|' ![\|=] skip
8133		PIPE2 <- '\|\|' skip
8134		PIPEEQUAL <- '\|=' skip
8135		PLUS <- '+' ![%+=] skip
8136		PLUS2 <- '++' skip
8137		PLUSEQUAL <- '+=' skip
8138		PLUSPERCENT <- '+%' ![=] skip
8139		PLUSPERCENTEQUAL <- '+%=' skip
8140		QUESTIONMARK <- '?' skip
8141		RARROW <- '>' ![>=] skip
8142		RARROW2 <- '>>' ![=] skip
8143		RARROW2EQUAL <- '>>=' skip
8144		RARROWEQUAL <- '>=' skip
8145		RBRACE <- '}' skip
8146		RBRACKET <- ']' skip
8147		RPAREN <- ')' skip
8148		SEMICOLON <- ';' skip
8149		SLASH <- '/' ![=] skip
8150		SLASHEQUAL <- '/=' skip
8151		TILDE <- '~' skip
8152
8153		end_of_word <- ![a-zA-Z0-9_] skip
8154		KEYWORD_align <- 'align' end_of_word
8155		KEYWORD_and <- 'and' end_of_word
8156		KEYWORD_anyerror <- 'anyerror' end_of_word
8157		KEYWORD_asm <- 'asm' end_of_word
8158		KEYWORD_async <- 'async' end_of_word
8159		KEYWORD_await <- 'await' end_of_word
8160		KEYWORD_break <- 'break' end_of_word
8161		KEYWORD_cancel <- 'cancel' end_of_word
8162		KEYWORD_catch <- 'catch' end_of_word
8163		KEYWORD_comptime <- 'comptime' end_of_word
8164		KEYWORD_const <- 'const' end_of_word
8165		KEYWORD_continue <- 'continue' end_of_word
8166		KEYWORD_defer <- 'defer' end_of_word
8167		KEYWORD_else <- 'else' end_of_word
8168		KEYWORD_enum <- 'enum' end_of_word
8169		KEYWORD_errdefer <- 'errdefer' end_of_word
8170		KEYWORD_error <- 'error' end_of_word
8171		KEYWORD_export <- 'export' end_of_word
8172		KEYWORD_extern <- 'extern' end_of_word
8173		KEYWORD_false <- 'false' end_of_word
8174		KEYWORD_fn <- 'fn' end_of_word
8175		KEYWORD_for <- 'for' end_of_word
8176		KEYWORD_if <- 'if' end_of_word
8177		KEYWORD_inline <- 'inline' end_of_word
8178		KEYWORD_nakedcc <- 'nakedcc' end_of_word
8179		KEYWORD_noalias <- 'noalias' end_of_word
8180		KEYWORD_null <- 'null' end_of_word
8181		KEYWORD_or <- 'or' end_of_word
8182		KEYWORD_orelse <- 'orelse' end_of_word
8183		KEYWORD_packed <- 'packed' end_of_word
8184		KEYWORD_promise <- 'promise' end_of_word
8185		KEYWORD_pub <- 'pub' end_of_word
8186		KEYWORD_resume <- 'resume' end_of_word
8187		KEYWORD_return <- 'return' end_of_word
8188		KEYWORD_section <- 'section' end_of_word
8189		KEYWORD_stdcallcc <- 'stdcallcc' end_of_word
8190		KEYWORD_struct <- 'struct' end_of_word
8191		KEYWORD_suspend <- 'suspend' end_of_word
8192		KEYWORD_switch <- 'switch' end_of_word
8193		KEYWORD_test <- 'test' end_of_word
8194		KEYWORD_true <- 'true' end_of_word
8195		KEYWORD_try <- 'try' end_of_word
8196		KEYWORD_undefined <- 'undefined' end_of_word
8197		KEYWORD_union <- 'union' end_of_word
8198		KEYWORD_unreachable <- 'unreachable' end_of_word
8199		KEYWORD_use <- 'use' end_of_word
8200		KEYWORD_var <- 'var' end_of_word
8201		KEYWORD_volatile <- 'volatile' end_of_word
8202		KEYWORD_while <- 'while' end_of_word
8203
8204		keyword <- KEYWORD_align / KEYWORD_and / KEYWORD_anyerror / KEYWORD_asm
	8093	BUILTININDENTIFIER <- "@"[A-Za-z_][A-Za-z0-9_]* skip
	8094
	8095
	8096	AMPERSAND <- '&' ![=] skip
	8097	AMPERSANDEQUAL <- '&=' skip
	8098	ASTERISK <- '' ![%=] skip
	8099	ASTERISK2 <- '**' skip
	8100	ASTERISKEQUAL <- '*=' skip
	8101	ASTERISKPERCENT <- '*%' ![=] skip
	8102	ASTERISKPERCENTEQUAL <- '*%=' skip
	8103	CARET <- '^' ![=] skip
	8104	CARETEQUAL <- '^=' skip
	8105	COLON <- ':' skip
	8106	COMMA <- ',' skip
	8107	DOT <- '.' ![*.?] skip
	8108	DOT2 <- '..' ![.] skip
	8109	DOT3 <- '...' skip
	8110	DOTASTERISK <- '.*' skip
	8111	DOTQUESTIONMARK <- '.?' skip
	8112	EQUAL <- '=' ![>=] skip
	8113	EQUALEQUAL <- '==' skip
	8114	EQUALRARROW <- '=>' skip
	8115	EXCLAMATIONMARK <- '!' ![=] skip
	8116	EXCLAMATIONMARKEQUAL <- '!=' skip
	8117	LARROW <- '<' ![<=] skip
	8118	LARROW2 <- '<<' ![=] skip
	8119	LARROW2EQUAL <- '<<=' skip
	8120	LARROWEQUAL <- '<=' skip
	8121	LBRACE <- '{' skip
	8122	LBRACKET <- '[' skip
	8123	LPAREN <- '(' skip
	8124	MINUS <- '-' ![%=>] skip
	8125	MINUSEQUAL <- '-=' skip
	8126	MINUSPERCENT <- '-%' ![=] skip
	8127	MINUSPERCENTEQUAL <- '-%=' skip
	8128	MINUSRARROW <- '->' skip
	8129	PERCENT <- '%' ![=] skip
	8130	PERCENTEQUAL <- '%=' skip
	8131	PIPE <- '\|' ![\|=] skip
	8132	PIPE2 <- '\|\|' skip
	8133	PIPEEQUAL <- '\|=' skip
	8134	PLUS <- '+' ![%+=] skip
	8135	PLUS2 <- '++' skip
	8136	PLUSEQUAL <- '+=' skip
	8137	PLUSPERCENT <- '+%' ![=] skip
	8138	PLUSPERCENTEQUAL <- '+%=' skip
	8139	QUESTIONMARK <- '?' skip
	8140	RARROW <- '>' ![>=] skip
	8141	RARROW2 <- '>>' ![=] skip
	8142	RARROW2EQUAL <- '>>=' skip
	8143	RARROWEQUAL <- '>=' skip
	8144	RBRACE <- '}' skip
	8145	RBRACKET <- ']' skip
	8146	RPAREN <- ')' skip
	8147	SEMICOLON <- ';' skip
	8148	SLASH <- '/' ![=] skip
	8149	SLASHEQUAL <- '/=' skip
	8150	TILDE <- '~' skip
	8151
	8152	end_of_word <- ![a-zA-Z0-9_] skip
	8153	KEYWORD_align <- 'align' end_of_word
	8154	KEYWORD_and <- 'and' end_of_word
	8155	KEYWORD_anyerror <- 'anyerror' end_of_word
	8156	KEYWORD_asm <- 'asm' end_of_word
	8157	KEYWORD_async <- 'async' end_of_word
	8158	KEYWORD_await <- 'await' end_of_word
	8159	KEYWORD_break <- 'break' end_of_word
	8160	KEYWORD_cancel <- 'cancel' end_of_word
	8161	KEYWORD_catch <- 'catch' end_of_word
	8162	KEYWORD_comptime <- 'comptime' end_of_word
	8163	KEYWORD_const <- 'const' end_of_word
	8164	KEYWORD_continue <- 'continue' end_of_word
	8165	KEYWORD_defer <- 'defer' end_of_word
	8166	KEYWORD_else <- 'else' end_of_word
	8167	KEYWORD_enum <- 'enum' end_of_word
	8168	KEYWORD_errdefer <- 'errdefer' end_of_word
	8169	KEYWORD_error <- 'error' end_of_word
	8170	KEYWORD_export <- 'export' end_of_word
	8171	KEYWORD_extern <- 'extern' end_of_word
	8172	KEYWORD_false <- 'false' end_of_word
	8173	KEYWORD_fn <- 'fn' end_of_word
	8174	KEYWORD_for <- 'for' end_of_word
	8175	KEYWORD_if <- 'if' end_of_word
	8176	KEYWORD_inline <- 'inline' end_of_word
	8177	KEYWORD_nakedcc <- 'nakedcc' end_of_word
	8178	KEYWORD_noalias <- 'noalias' end_of_word
	8179	KEYWORD_null <- 'null' end_of_word
	8180	KEYWORD_or <- 'or' end_of_word
	8181	KEYWORD_orelse <- 'orelse' end_of_word
	8182	KEYWORD_packed <- 'packed' end_of_word
	8183	KEYWORD_promise <- 'promise' end_of_word
	8184	KEYWORD_pub <- 'pub' end_of_word
	8185	KEYWORD_resume <- 'resume' end_of_word
	8186	KEYWORD_return <- 'return' end_of_word
	8187	KEYWORD_linksection <- 'linksection' end_of_word
	8188	KEYWORD_stdcallcc <- 'stdcallcc' end_of_word
	8189	KEYWORD_struct <- 'struct' end_of_word
	8190	KEYWORD_suspend <- 'suspend' end_of_word
	8191	KEYWORD_switch <- 'switch' end_of_word
	8192	KEYWORD_test <- 'test' end_of_word
	8193	KEYWORD_true <- 'true' end_of_word
	8194	KEYWORD_try <- 'try' end_of_word
	8195	KEYWORD_undefined <- 'undefined' end_of_word
	8196	KEYWORD_union <- 'union' end_of_word
	8197	KEYWORD_unreachable <- 'unreachable' end_of_word
	8198	KEYWORD_use <- 'use' end_of_word
	8199	KEYWORD_var <- 'var' end_of_word
	8200	KEYWORD_volatile <- 'volatile' end_of_word
	8201	KEYWORD_while <- 'while' end_of_word
	8202
	8203	keyword <- KEYWORD_align / KEYWORD_and / KEYWORD_anyerror / KEYWORD_asm
8205	8204	/ KEYWORD_async / KEYWORD_await / KEYWORD_break / KEYWORD_cancel
8206	8205	/ KEYWORD_catch / KEYWORD_comptime / KEYWORD_const / KEYWORD_continue
8207	8206	/ KEYWORD_defer / KEYWORD_else / KEYWORD_enum / KEYWORD_errdefer
...	...	@@ -8209,12 +8208,11 @@ keyword <- KEYWORD_align / KEYWORD_and / KEYWORD_anyerror / KEYWORD_asm
8209	8208	/ KEYWORD_fn / KEYWORD_for / KEYWORD_if / KEYWORD_inline
8210	8209	/ KEYWORD_nakedcc / KEYWORD_noalias / KEYWORD_null / KEYWORD_or
8211	8210	/ KEYWORD_orelse / KEYWORD_packed / KEYWORD_promise / KEYWORD_pub
8212		/ KEYWORD_resume / KEYWORD_return / KEYWORD_section
	8211	/ KEYWORD_resume / KEYWORD_return / KEYWORD_linksection
8213	8212	/ KEYWORD_stdcallcc / KEYWORD_struct / KEYWORD_suspend
8214	8213	/ KEYWORD_switch / KEYWORD_test / KEYWORD_true / KEYWORD_try
8215	8214	/ KEYWORD_undefined / KEYWORD_union / KEYWORD_unreachable
8216		/ KEYWORD_use / KEYWORD_var / KEYWORD_volatile / KEYWORD_while
8217		</code></pre>
	8215	/ KEYWORD_use / KEYWORD_var / KEYWORD_volatile / KEYWORD_while</code></pre>
8218	8216	{#header_close#}
8219	8217	{#header_open\|Zen#}
8220	8218	<ul>

src/parser.cpp+1-1

...	...	@@ -2082,7 +2082,7 @@ static AstNode ast_parse_while_continue_expr(ParseContext pc) {
2082	2082
2083	2083	// Section <- KEYWORD_section LPAREN Expr RPAREN
2084	2084	static AstNode ast_parse_section(ParseContext pc) {
2085		Token *first = eat_token_if(pc, TokenIdKeywordSection);
	2085	Token *first = eat_token_if(pc, TokenIdKeywordLinkSection);
2086	2086	if (first == nullptr)
2087	2087	return nullptr;
2088	2088

src/tokenizer.cpp+2-2

...	...	@@ -140,7 +140,7 @@ static const struct ZigKeyword zig_keywords[] = {
140	140	{"pub", TokenIdKeywordPub},
141	141	{"resume", TokenIdKeywordResume},
142	142	{"return", TokenIdKeywordReturn},
143		{"section", TokenIdKeywordSection},
	143	{"linksection", TokenIdKeywordLinkSection},
144	144	{"stdcallcc", TokenIdKeywordStdcallCC},
145	145	{"struct", TokenIdKeywordStruct},
146	146	{"suspend", TokenIdKeywordSuspend},
...	...	@@ -1583,7 +1583,7 @@ const char * token_name(TokenId id) {
1583	1583	case TokenIdKeywordPromise: return "promise";
1584	1584	case TokenIdKeywordPub: return "pub";
1585	1585	case TokenIdKeywordReturn: return "return";
1586		case TokenIdKeywordSection: return "section";
	1586	case TokenIdKeywordLinkSection: return "linksection";
1587	1587	case TokenIdKeywordStdcallCC: return "stdcallcc";
1588	1588	case TokenIdKeywordStruct: return "struct";
1589	1589	case TokenIdKeywordSwitch: return "switch";

src/tokenizer.hpp+1-1

...	...	@@ -82,7 +82,7 @@ enum TokenId {
82	82	TokenIdKeywordPub,
83	83	TokenIdKeywordResume,
84	84	TokenIdKeywordReturn,
85		TokenIdKeywordSection,
	85	TokenIdKeywordLinkSection,
86	86	TokenIdKeywordStdcallCC,
87	87	TokenIdKeywordStruct,
88	88	TokenIdKeywordSuspend,

std/zig/ast.zig+12

...	...	@@ -503,6 +503,7 @@ pub const Node = struct {
503	503	lib_name: ?*Node,
504	504	type_node: ?*Node,
505	505	align_node: ?*Node,
	506	section_node: ?*Node,
506	507	init_node: ?*Node,
507	508	semicolon_token: TokenIndex,
508	509
...	...	@@ -519,6 +520,11 @@ pub const Node = struct {
519	520	i -= 1;
520	521	}
521	522
	523	if (self.section_node) \|section_node\| {
	524	if (i < 1) return section_node;
	525	i -= 1;
	526	}
	527
522	528	if (self.init_node) \|init_node\| {
523	529	if (i < 1) return init_node;
524	530	i -= 1;
...	...	@@ -821,6 +827,7 @@ pub const Node = struct {
821	827	body_node: ?*Node,
822	828	lib_name: ?*Node, // populated if this is an extern declaration
823	829	align_expr: ?*Node, // populated if align(A) is present
	830	section_expr: ?*Node, // populated if linksection(A) is present
824	831
825	832	pub const ParamList = SegmentedList(*Node, 2);
826	833
...	...	@@ -845,6 +852,11 @@ pub const Node = struct {
845	852	i -= 1;
846	853	}
847	854
	855	if (self.section_expr) \|section_expr\| {
	856	if (i < 1) return section_expr;
	857	i -= 1;
	858	}
	859
848	860	switch (self.return_type) {
849	861	// TODO allow this and next prong to share bodies since the types are the same
850	862	ReturnType.Explicit => \|node\| {

std/zig/parse.zig+35-2

...	...	@@ -291,6 +291,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
291	291	.body_node = null,
292	292	.lib_name = ctx.lib_name,
293	293	.align_expr = null,
	294	.section_expr = null,
294	295	});
295	296	try ctx.decls.push(&fn_proto.base);
296	297	stack.append(State{ .FnDef = fn_proto }) catch unreachable;
...	...	@@ -601,6 +602,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
601	602	.extern_export_token = ctx.extern_export_token,
602	603	.type_node = null,
603	604	.align_node = null,
	605	.section_node = null,
604	606	.init_node = null,
605	607	.lib_name = ctx.lib_name,
606	608	// initialized later
...	...	@@ -622,7 +624,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
622	624	continue;
623	625	},
624	626	State.VarDeclAlign => \|var_decl\| {
625		try stack.append(State{ .VarDeclEq = var_decl });
	627	try stack.append(State{ .VarDeclSection = var_decl });
626	628
627	629	const next_token = nextToken(&tok_it, &tree);
628	630	const next_token_index = next_token.index;
...	...	@@ -637,6 +639,22 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
637	639	prevToken(&tok_it, &tree);
638	640	continue;
639	641	},
	642	State.VarDeclSection => \|var_decl\| {
	643	try stack.append(State{ .VarDeclEq = var_decl });
	644
	645	const next_token = nextToken(&tok_it, &tree);
	646	const next_token_index = next_token.index;
	647	const next_token_ptr = next_token.ptr;
	648	if (next_token_ptr.id == Token.Id.Keyword_linksection) {
	649	try stack.append(State{ .ExpectToken = Token.Id.RParen });
	650	try stack.append(State{ .Expression = OptionalCtx{ .RequiredNull = &var_decl.section_node } });
	651	try stack.append(State{ .ExpectToken = Token.Id.LParen });
	652	continue;
	653	}
	654
	655	prevToken(&tok_it, &tree);
	656	continue;
	657	},
640	658	State.VarDeclEq => \|var_decl\| {
641	659	const token = nextToken(&tok_it, &tree);
642	660	const token_index = token.index;
...	...	@@ -719,7 +737,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
719	737	continue;
720	738	},
721	739	State.FnProtoAlign => \|fn_proto\| {
722		stack.append(State{ .FnProtoReturnType = fn_proto }) catch unreachable;
	740	stack.append(State{ .FnProtoSection = fn_proto }) catch unreachable;
723	741
724	742	if (eatToken(&tok_it, &tree, Token.Id.Keyword_align)) \|align_token\| {
725	743	try stack.append(State{ .ExpectToken = Token.Id.RParen });
...	...	@@ -728,6 +746,16 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
728	746	}
729	747	continue;
730	748	},
	749	State.FnProtoSection => \|fn_proto\| {
	750	stack.append(State{ .FnProtoReturnType = fn_proto }) catch unreachable;
	751
	752	if (eatToken(&tok_it, &tree, Token.Id.Keyword_linksection)) \|align_token\| {
	753	try stack.append(State{ .ExpectToken = Token.Id.RParen });
	754	try stack.append(State{ .Expression = OptionalCtx{ .RequiredNull = &fn_proto.section_expr } });
	755	try stack.append(State{ .ExpectToken = Token.Id.LParen });
	756	}
	757	continue;
	758	},
731	759	State.FnProtoReturnType => \|fn_proto\| {
732	760	const token = nextToken(&tok_it, &tree);
733	761	const token_index = token.index;
...	...	@@ -1524,6 +1552,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
1524	1552	.body_node = null,
1525	1553	.lib_name = null,
1526	1554	.align_expr = null,
	1555	.section_expr = null,
1527	1556	});
1528	1557	ctx.opt_ctx.store(&fn_proto.base);
1529	1558	stack.append(State{ .FnProto = fn_proto }) catch unreachable;
...	...	@@ -2579,6 +2608,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
2579	2608	.body_node = null,
2580	2609	.lib_name = null,
2581	2610	.align_expr = null,
	2611	.section_expr = null,
2582	2612	});
2583	2613	opt_ctx.store(&fn_proto.base);
2584	2614	stack.append(State{ .FnProto = fn_proto }) catch unreachable;
...	...	@@ -2600,6 +2630,7 @@ pub fn parse(allocator: *mem.Allocator, source: []const u8) !ast.Tree {
2600	2630	.body_node = null,
2601	2631	.lib_name = null,
2602	2632	.align_expr = null,
	2633	.section_expr = null,
2603	2634	});
2604	2635	opt_ctx.store(&fn_proto.base);
2605	2636	stack.append(State{ .FnProto = fn_proto }) catch unreachable;
...	...	@@ -2985,12 +3016,14 @@ const State = union(enum) {
2985	3016
2986	3017	VarDecl: VarDeclCtx,
2987	3018	VarDeclAlign: *ast.Node.VarDecl,
	3019	VarDeclSection: *ast.Node.VarDecl,
2988	3020	VarDeclEq: *ast.Node.VarDecl,
2989	3021	VarDeclSemiColon: *ast.Node.VarDecl,
2990	3022
2991	3023	FnDef: *ast.Node.FnProto,
2992	3024	FnProto: *ast.Node.FnProto,
2993	3025	FnProtoAlign: *ast.Node.FnProto,
	3026	FnProtoSection: *ast.Node.FnProto,
2994	3027	FnProtoReturnType: *ast.Node.FnProto,
2995	3028
2996	3029	ParamDecl: *ast.Node.FnProto,

std/zig/parser_test.zig+7

...	...	@@ -1,3 +1,10 @@
	1	test "zig fmt: linksection" {
	2	try testCanonical(
	3	\\export var aoeu: u64 linksection(".text.derp") = 1234;
	4	\\export nakedcc fn _start() linksection(".text.boot") noreturn {}
	5	\\
	6	);
	7	}
1	8	test "zig fmt: shebang line" {
2	9	try testCanonical(
3	10	\\#!/usr/bin/env zig

std/zig/render.zig+26-2

...	...	@@ -1148,6 +1148,17 @@ fn renderExpression(
1148	1148	try renderToken(tree, stream, align_rparen, indent, start_col, Space.Space); // )
1149	1149	}
1150	1150
	1151	if (fn_proto.section_expr) \|section_expr\| {
	1152	const section_rparen = tree.nextToken(section_expr.lastToken());
	1153	const section_lparen = tree.prevToken(section_expr.firstToken());
	1154	const section_kw = tree.prevToken(section_lparen);
	1155
	1156	try renderToken(tree, stream, section_kw, indent, start_col, Space.None); // section
	1157	try renderToken(tree, stream, section_lparen, indent, start_col, Space.None); // (
	1158	try renderExpression(allocator, stream, tree, indent, start_col, section_expr, Space.None);
	1159	try renderToken(tree, stream, section_rparen, indent, start_col, Space.Space); // )
	1160	}
	1161
1151	1162	switch (fn_proto.return_type) {
1152	1163	ast.Node.FnProto.ReturnType.Explicit => \|node\| {
1153	1164	return renderExpression(allocator, stream, tree, indent, start_col, node, space);
...	...	@@ -1698,12 +1709,14 @@ fn renderVarDecl(
1698	1709	try renderToken(tree, stream, var_decl.mut_token, indent, start_col, Space.Space); // var
1699	1710
1700	1711	const name_space = if (var_decl.type_node == null and (var_decl.align_node != null or
1701		var_decl.init_node != null)) Space.Space else Space.None;
	1712	var_decl.section_node != null or var_decl.init_node != null)) Space.Space else Space.None;
1702	1713	try renderToken(tree, stream, var_decl.name_token, indent, start_col, name_space);
1703	1714
1704	1715	if (var_decl.type_node) \|type_node\| {
1705	1716	try renderToken(tree, stream, tree.nextToken(var_decl.name_token), indent, start_col, Space.Space);
1706		const s = if (var_decl.align_node != null or var_decl.init_node != null) Space.Space else Space.None;
	1717	const s = if (var_decl.align_node != null or
	1718	var_decl.section_node != null or
	1719	var_decl.init_node != null) Space.Space else Space.None;
1707	1720	try renderExpression(allocator, stream, tree, indent, start_col, type_node, s);
1708	1721	}
1709	1722
...	...	@@ -1714,6 +1727,17 @@ fn renderVarDecl(
1714	1727	try renderToken(tree, stream, align_kw, indent, start_col, Space.None); // align
1715	1728	try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
1716	1729	try renderExpression(allocator, stream, tree, indent, start_col, align_node, Space.None);
	1730	const s = if (var_decl.section_node != null or var_decl.init_node != null) Space.Space else Space.None;
	1731	try renderToken(tree, stream, rparen, indent, start_col, s); // )
	1732	}
	1733
	1734	if (var_decl.section_node) \|section_node\| {
	1735	const lparen = tree.prevToken(section_node.firstToken());
	1736	const section_kw = tree.prevToken(lparen);
	1737	const rparen = tree.nextToken(section_node.lastToken());
	1738	try renderToken(tree, stream, section_kw, indent, start_col, Space.None); // linksection
	1739	try renderToken(tree, stream, lparen, indent, start_col, Space.None); // (
	1740	try renderExpression(allocator, stream, tree, indent, start_col, section_node, Space.None);
1717	1741	const s = if (var_decl.init_node != null) Space.Space else Space.None;
1718	1742	try renderToken(tree, stream, rparen, indent, start_col, s); // )
1719	1743	}

std/zig/tokenizer.zig+2-2

...	...	@@ -46,7 +46,7 @@ pub const Token = struct {
46	46	Keyword{ .bytes = "pub", .id = Id.Keyword_pub },
47	47	Keyword{ .bytes = "resume", .id = Id.Keyword_resume },
48	48	Keyword{ .bytes = "return", .id = Id.Keyword_return },
49		Keyword{ .bytes = "section", .id = Id.Keyword_section },
	49	Keyword{ .bytes = "linksection", .id = Id.Keyword_linksection },
50	50	Keyword{ .bytes = "stdcallcc", .id = Id.Keyword_stdcallcc },
51	51	Keyword{ .bytes = "struct", .id = Id.Keyword_struct },
52	52	Keyword{ .bytes = "suspend", .id = Id.Keyword_suspend },
...	...	@@ -175,7 +175,7 @@ pub const Token = struct {
175	175	Keyword_pub,
176	176	Keyword_resume,
177	177	Keyword_return,
178		Keyword_section,
	178	Keyword_linksection,
179	179	Keyword_stdcallcc,
180	180	Keyword_struct,
181	181	Keyword_suspend,

test/compile_errors.zig+6-6

...	...	@@ -3867,32 +3867,32 @@ pub fn addCases(cases: *tests.CompileErrorContext) void {
3867	3867
3868	3868	cases.add(
3869	3869	"setting a section on an extern variable",
3870		\\extern var foo: i32 section(".text2");
	3870	\\extern var foo: i32 linksection(".text2");
3871	3871	\\export fn entry() i32 {
3872	3872	\\ return foo;
3873	3873	\\}
3874	3874	,
3875		".tmp_source.zig:1:29: error: cannot set section of external variable 'foo'",
	3875	".tmp_source.zig:1:33: error: cannot set section of external variable 'foo'",
3876	3876	);
3877	3877
3878	3878	cases.add(
3879	3879	"setting a section on a local variable",
3880	3880	\\export fn entry() i32 {
3881		\\ var foo: i32 section(".text2") = 1234;
	3881	\\ var foo: i32 linksection(".text2") = 1234;
3882	3882	\\ return foo;
3883	3883	\\}
3884	3884	,
3885		".tmp_source.zig:2:26: error: cannot set section of local variable 'foo'",
	3885	".tmp_source.zig:2:30: error: cannot set section of local variable 'foo'",
3886	3886	);
3887	3887
3888	3888	cases.add(
3889	3889	"setting a section on an extern fn",
3890		\\extern fn foo() section(".text2") void;
	3890	\\extern fn foo() linksection(".text2") void;
3891	3891	\\export fn entry() void {
3892	3892	\\ foo();
3893	3893	\\}
3894	3894	,
3895		".tmp_source.zig:1:25: error: cannot set section of external function 'foo'",
	3895	".tmp_source.zig:1:29: error: cannot set section of external function 'foo'",
3896	3896	);
3897	3897
3898	3898	cases.add(