authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-07-19 17:55:12-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2019-07-19 17:55:12-04:00
logf429f4dcabec2324b76b900f5785204897ea7685
tree86e7d61f3ed055c54dbe49a5ed4ab9f2942d8d17
parentaf8661405b908c0abfc191501a8ad1a59a54e86a
parent8ea8cff4912bf66b8e95b7518877c7f55c7a9356
signaturelock-open Commit is signed but in an unrecognized format.

Merge branch 'fengb-tokenize-ampamp'

closes #2723 closes #2660

4 files changed, 234 insertions(+), 219 deletions(-)

doc/docgen.zig+118-118
......@@ -742,101 +742,101 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: var, source_token: Tok
742742 const token = tokenizer.next();
743743 try writeEscaped(out, src[index..token.start]);
744744 switch (token.id) {
745 std.zig.Token.Id.Eof => break,
746
747 std.zig.Token.Id.Keyword_align,
748 std.zig.Token.Id.Keyword_and,
749 std.zig.Token.Id.Keyword_asm,
750 std.zig.Token.Id.Keyword_async,
751 std.zig.Token.Id.Keyword_await,
752 std.zig.Token.Id.Keyword_break,
753 std.zig.Token.Id.Keyword_cancel,
754 std.zig.Token.Id.Keyword_catch,
755 std.zig.Token.Id.Keyword_comptime,
756 std.zig.Token.Id.Keyword_const,
757 std.zig.Token.Id.Keyword_continue,
758 std.zig.Token.Id.Keyword_defer,
759 std.zig.Token.Id.Keyword_else,
760 std.zig.Token.Id.Keyword_enum,
761 std.zig.Token.Id.Keyword_errdefer,
762 std.zig.Token.Id.Keyword_error,
763 std.zig.Token.Id.Keyword_export,
764 std.zig.Token.Id.Keyword_extern,
765 std.zig.Token.Id.Keyword_for,
766 std.zig.Token.Id.Keyword_if,
767 std.zig.Token.Id.Keyword_inline,
768 std.zig.Token.Id.Keyword_nakedcc,
769 std.zig.Token.Id.Keyword_noalias,
770 std.zig.Token.Id.Keyword_or,
771 std.zig.Token.Id.Keyword_orelse,
772 std.zig.Token.Id.Keyword_packed,
773 std.zig.Token.Id.Keyword_promise,
774 std.zig.Token.Id.Keyword_pub,
775 std.zig.Token.Id.Keyword_resume,
776 std.zig.Token.Id.Keyword_return,
777 std.zig.Token.Id.Keyword_linksection,
778 std.zig.Token.Id.Keyword_stdcallcc,
779 std.zig.Token.Id.Keyword_struct,
780 std.zig.Token.Id.Keyword_suspend,
781 std.zig.Token.Id.Keyword_switch,
782 std.zig.Token.Id.Keyword_test,
783 std.zig.Token.Id.Keyword_threadlocal,
784 std.zig.Token.Id.Keyword_try,
785 std.zig.Token.Id.Keyword_union,
786 std.zig.Token.Id.Keyword_unreachable,
787 std.zig.Token.Id.Keyword_usingnamespace,
788 std.zig.Token.Id.Keyword_var,
789 std.zig.Token.Id.Keyword_volatile,
790 std.zig.Token.Id.Keyword_allowzero,
791 std.zig.Token.Id.Keyword_while,
745 .Eof => break,
746
747 .Keyword_align,
748 .Keyword_and,
749 .Keyword_asm,
750 .Keyword_async,
751 .Keyword_await,
752 .Keyword_break,
753 .Keyword_cancel,
754 .Keyword_catch,
755 .Keyword_comptime,
756 .Keyword_const,
757 .Keyword_continue,
758 .Keyword_defer,
759 .Keyword_else,
760 .Keyword_enum,
761 .Keyword_errdefer,
762 .Keyword_error,
763 .Keyword_export,
764 .Keyword_extern,
765 .Keyword_for,
766 .Keyword_if,
767 .Keyword_inline,
768 .Keyword_nakedcc,
769 .Keyword_noalias,
770 .Keyword_or,
771 .Keyword_orelse,
772 .Keyword_packed,
773 .Keyword_promise,
774 .Keyword_pub,
775 .Keyword_resume,
776 .Keyword_return,
777 .Keyword_linksection,
778 .Keyword_stdcallcc,
779 .Keyword_struct,
780 .Keyword_suspend,
781 .Keyword_switch,
782 .Keyword_test,
783 .Keyword_threadlocal,
784 .Keyword_try,
785 .Keyword_union,
786 .Keyword_unreachable,
787 .Keyword_usingnamespace,
788 .Keyword_var,
789 .Keyword_volatile,
790 .Keyword_allowzero,
791 .Keyword_while,
792792 => {
793793 try out.write("<span class=\"tok-kw\">");
794794 try writeEscaped(out, src[token.start..token.end]);
795795 try out.write("</span>");
796796 },
797797
798 std.zig.Token.Id.Keyword_fn => {
798 .Keyword_fn => {
799799 try out.write("<span class=\"tok-kw\">");
800800 try writeEscaped(out, src[token.start..token.end]);
801801 try out.write("</span>");
802802 next_tok_is_fn = true;
803803 },
804804
805 std.zig.Token.Id.Keyword_undefined,
806 std.zig.Token.Id.Keyword_null,
807 std.zig.Token.Id.Keyword_true,
808 std.zig.Token.Id.Keyword_false,
805 .Keyword_undefined,
806 .Keyword_null,
807 .Keyword_true,
808 .Keyword_false,
809809 => {
810810 try out.write("<span class=\"tok-null\">");
811811 try writeEscaped(out, src[token.start..token.end]);
812812 try out.write("</span>");
813813 },
814814
815 std.zig.Token.Id.StringLiteral,
816 std.zig.Token.Id.MultilineStringLiteralLine,
817 std.zig.Token.Id.CharLiteral,
815 .StringLiteral,
816 .MultilineStringLiteralLine,
817 .CharLiteral,
818818 => {
819819 try out.write("<span class=\"tok-str\">");
820820 try writeEscaped(out, src[token.start..token.end]);
821821 try out.write("</span>");
822822 },
823823
824 std.zig.Token.Id.Builtin => {
824 .Builtin => {
825825 try out.write("<span class=\"tok-builtin\">");
826826 try writeEscaped(out, src[token.start..token.end]);
827827 try out.write("</span>");
828828 },
829829
830 std.zig.Token.Id.LineComment,
831 std.zig.Token.Id.DocComment,
832 std.zig.Token.Id.ShebangLine,
830 .LineComment,
831 .DocComment,
832 .ShebangLine,
833833 => {
834834 try out.write("<span class=\"tok-comment\">");
835835 try writeEscaped(out, src[token.start..token.end]);
836836 try out.write("</span>");
837837 },
838838
839 std.zig.Token.Id.Identifier => {
839 .Identifier => {
840840 if (prev_tok_was_fn) {
841841 try out.write("<span class=\"tok-fn\">");
842842 try writeEscaped(out, src[token.start..token.end]);
......@@ -864,72 +864,72 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: var, source_token: Tok
864864 }
865865 },
866866
867 std.zig.Token.Id.IntegerLiteral,
868 std.zig.Token.Id.FloatLiteral,
867 .IntegerLiteral,
868 .FloatLiteral,
869869 => {
870870 try out.write("<span class=\"tok-number\">");
871871 try writeEscaped(out, src[token.start..token.end]);
872872 try out.write("</span>");
873873 },
874874
875 std.zig.Token.Id.Bang,
876 std.zig.Token.Id.Pipe,
877 std.zig.Token.Id.PipePipe,
878 std.zig.Token.Id.PipeEqual,
879 std.zig.Token.Id.Equal,
880 std.zig.Token.Id.EqualEqual,
881 std.zig.Token.Id.EqualAngleBracketRight,
882 std.zig.Token.Id.BangEqual,
883 std.zig.Token.Id.LParen,
884 std.zig.Token.Id.RParen,
885 std.zig.Token.Id.Semicolon,
886 std.zig.Token.Id.Percent,
887 std.zig.Token.Id.PercentEqual,
888 std.zig.Token.Id.LBrace,
889 std.zig.Token.Id.RBrace,
890 std.zig.Token.Id.LBracket,
891 std.zig.Token.Id.RBracket,
892 std.zig.Token.Id.Period,
893 std.zig.Token.Id.Ellipsis2,
894 std.zig.Token.Id.Ellipsis3,
895 std.zig.Token.Id.Caret,
896 std.zig.Token.Id.CaretEqual,
897 std.zig.Token.Id.Plus,
898 std.zig.Token.Id.PlusPlus,
899 std.zig.Token.Id.PlusEqual,
900 std.zig.Token.Id.PlusPercent,
901 std.zig.Token.Id.PlusPercentEqual,
902 std.zig.Token.Id.Minus,
903 std.zig.Token.Id.MinusEqual,
904 std.zig.Token.Id.MinusPercent,
905 std.zig.Token.Id.MinusPercentEqual,
906 std.zig.Token.Id.Asterisk,
907 std.zig.Token.Id.AsteriskEqual,
908 std.zig.Token.Id.AsteriskAsterisk,
909 std.zig.Token.Id.AsteriskPercent,
910 std.zig.Token.Id.AsteriskPercentEqual,
911 std.zig.Token.Id.Arrow,
912 std.zig.Token.Id.Colon,
913 std.zig.Token.Id.Slash,
914 std.zig.Token.Id.SlashEqual,
915 std.zig.Token.Id.Comma,
916 std.zig.Token.Id.Ampersand,
917 std.zig.Token.Id.AmpersandEqual,
918 std.zig.Token.Id.QuestionMark,
919 std.zig.Token.Id.AngleBracketLeft,
920 std.zig.Token.Id.AngleBracketLeftEqual,
921 std.zig.Token.Id.AngleBracketAngleBracketLeft,
922 std.zig.Token.Id.AngleBracketAngleBracketLeftEqual,
923 std.zig.Token.Id.AngleBracketRight,
924 std.zig.Token.Id.AngleBracketRightEqual,
925 std.zig.Token.Id.AngleBracketAngleBracketRight,
926 std.zig.Token.Id.AngleBracketAngleBracketRightEqual,
927 std.zig.Token.Id.Tilde,
928 std.zig.Token.Id.BracketStarBracket,
929 std.zig.Token.Id.BracketStarCBracket,
875 .Bang,
876 .Pipe,
877 .PipePipe,
878 .PipeEqual,
879 .Equal,
880 .EqualEqual,
881 .EqualAngleBracketRight,
882 .BangEqual,
883 .LParen,
884 .RParen,
885 .Semicolon,
886 .Percent,
887 .PercentEqual,
888 .LBrace,
889 .RBrace,
890 .LBracket,
891 .RBracket,
892 .Period,
893 .Ellipsis2,
894 .Ellipsis3,
895 .Caret,
896 .CaretEqual,
897 .Plus,
898 .PlusPlus,
899 .PlusEqual,
900 .PlusPercent,
901 .PlusPercentEqual,
902 .Minus,
903 .MinusEqual,
904 .MinusPercent,
905 .MinusPercentEqual,
906 .Asterisk,
907 .AsteriskEqual,
908 .AsteriskAsterisk,
909 .AsteriskPercent,
910 .AsteriskPercentEqual,
911 .Arrow,
912 .Colon,
913 .Slash,
914 .SlashEqual,
915 .Comma,
916 .Ampersand,
917 .AmpersandEqual,
918 .QuestionMark,
919 .AngleBracketLeft,
920 .AngleBracketLeftEqual,
921 .AngleBracketAngleBracketLeft,
922 .AngleBracketAngleBracketLeftEqual,
923 .AngleBracketRight,
924 .AngleBracketRightEqual,
925 .AngleBracketAngleBracketRight,
926 .AngleBracketAngleBracketRightEqual,
927 .Tilde,
928 .BracketStarBracket,
929 .BracketStarCBracket,
930930 => try writeEscaped(out, src[token.start..token.end]),
931931
932 std.zig.Token.Id.Invalid => return parseError(
932 .Invalid, .Invalid_ampersands => return parseError(
933933 docgen_tokenizer,
934934 source_token,
935935 "syntax error",
std/zig/ast.zig+109-100
......@@ -159,101 +159,99 @@ pub const Error = union(enum) {
159159
160160 pub fn render(self: *const Error, tokens: *Tree.TokenList, stream: var) !void {
161161 switch (self.*) {
162 // TODO https://github.com/ziglang/zig/issues/683
163 @TagType(Error).InvalidToken => |*x| return x.render(tokens, stream),
164 @TagType(Error).ExpectedContainerMembers => |*x| return x.render(tokens, stream),
165 @TagType(Error).ExpectedStringLiteral => |*x| return x.render(tokens, stream),
166 @TagType(Error).ExpectedIntegerLiteral => |*x| return x.render(tokens, stream),
167 @TagType(Error).ExpectedPubItem => |*x| return x.render(tokens, stream),
168 @TagType(Error).ExpectedIdentifier => |*x| return x.render(tokens, stream),
169 @TagType(Error).ExpectedStatement => |*x| return x.render(tokens, stream),
170 @TagType(Error).ExpectedVarDeclOrFn => |*x| return x.render(tokens, stream),
171 @TagType(Error).ExpectedVarDecl => |*x| return x.render(tokens, stream),
172 @TagType(Error).ExpectedReturnType => |*x| return x.render(tokens, stream),
173 @TagType(Error).ExpectedAggregateKw => |*x| return x.render(tokens, stream),
174 @TagType(Error).UnattachedDocComment => |*x| return x.render(tokens, stream),
175 @TagType(Error).ExpectedEqOrSemi => |*x| return x.render(tokens, stream),
176 @TagType(Error).ExpectedSemiOrLBrace => |*x| return x.render(tokens, stream),
177 @TagType(Error).ExpectedSemiOrElse => |*x| return x.render(tokens, stream),
178 @TagType(Error).ExpectedLabelOrLBrace => |*x| return x.render(tokens, stream),
179 @TagType(Error).ExpectedLBrace => |*x| return x.render(tokens, stream),
180 @TagType(Error).ExpectedColonOrRParen => |*x| return x.render(tokens, stream),
181 @TagType(Error).ExpectedLabelable => |*x| return x.render(tokens, stream),
182 @TagType(Error).ExpectedInlinable => |*x| return x.render(tokens, stream),
183 @TagType(Error).ExpectedAsmOutputReturnOrType => |*x| return x.render(tokens, stream),
184 @TagType(Error).ExpectedCall => |*x| return x.render(tokens, stream),
185 @TagType(Error).ExpectedCallOrFnProto => |*x| return x.render(tokens, stream),
186 @TagType(Error).ExpectedSliceOrRBracket => |*x| return x.render(tokens, stream),
187 @TagType(Error).ExtraAlignQualifier => |*x| return x.render(tokens, stream),
188 @TagType(Error).ExtraConstQualifier => |*x| return x.render(tokens, stream),
189 @TagType(Error).ExtraVolatileQualifier => |*x| return x.render(tokens, stream),
190 @TagType(Error).ExtraAllowZeroQualifier => |*x| return x.render(tokens, stream),
191 @TagType(Error).ExpectedTypeExpr => |*x| return x.render(tokens, stream),
192 @TagType(Error).ExpectedPrimaryTypeExpr => |*x| return x.render(tokens, stream),
193 @TagType(Error).ExpectedParamType => |*x| return x.render(tokens, stream),
194 @TagType(Error).ExpectedExpr => |*x| return x.render(tokens, stream),
195 @TagType(Error).ExpectedPrimaryExpr => |*x| return x.render(tokens, stream),
196 @TagType(Error).ExpectedToken => |*x| return x.render(tokens, stream),
197 @TagType(Error).ExpectedCommaOrEnd => |*x| return x.render(tokens, stream),
198 @TagType(Error).ExpectedParamList => |*x| return x.render(tokens, stream),
199 @TagType(Error).ExpectedPayload => |*x| return x.render(tokens, stream),
200 @TagType(Error).ExpectedBlockOrAssignment => |*x| return x.render(tokens, stream),
201 @TagType(Error).ExpectedBlockOrExpression => |*x| return x.render(tokens, stream),
202 @TagType(Error).ExpectedExprOrAssignment => |*x| return x.render(tokens, stream),
203 @TagType(Error).ExpectedPrefixExpr => |*x| return x.render(tokens, stream),
204 @TagType(Error).ExpectedLoopExpr => |*x| return x.render(tokens, stream),
205 @TagType(Error).ExpectedDerefOrUnwrap => |*x| return x.render(tokens, stream),
206 @TagType(Error).ExpectedSuffixOp => |*x| return x.render(tokens, stream),
162 .InvalidToken => |*x| return x.render(tokens, stream),
163 .ExpectedContainerMembers => |*x| return x.render(tokens, stream),
164 .ExpectedStringLiteral => |*x| return x.render(tokens, stream),
165 .ExpectedIntegerLiteral => |*x| return x.render(tokens, stream),
166 .ExpectedPubItem => |*x| return x.render(tokens, stream),
167 .ExpectedIdentifier => |*x| return x.render(tokens, stream),
168 .ExpectedStatement => |*x| return x.render(tokens, stream),
169 .ExpectedVarDeclOrFn => |*x| return x.render(tokens, stream),
170 .ExpectedVarDecl => |*x| return x.render(tokens, stream),
171 .ExpectedReturnType => |*x| return x.render(tokens, stream),
172 .ExpectedAggregateKw => |*x| return x.render(tokens, stream),
173 .UnattachedDocComment => |*x| return x.render(tokens, stream),
174 .ExpectedEqOrSemi => |*x| return x.render(tokens, stream),
175 .ExpectedSemiOrLBrace => |*x| return x.render(tokens, stream),
176 .ExpectedSemiOrElse => |*x| return x.render(tokens, stream),
177 .ExpectedLabelOrLBrace => |*x| return x.render(tokens, stream),
178 .ExpectedLBrace => |*x| return x.render(tokens, stream),
179 .ExpectedColonOrRParen => |*x| return x.render(tokens, stream),
180 .ExpectedLabelable => |*x| return x.render(tokens, stream),
181 .ExpectedInlinable => |*x| return x.render(tokens, stream),
182 .ExpectedAsmOutputReturnOrType => |*x| return x.render(tokens, stream),
183 .ExpectedCall => |*x| return x.render(tokens, stream),
184 .ExpectedCallOrFnProto => |*x| return x.render(tokens, stream),
185 .ExpectedSliceOrRBracket => |*x| return x.render(tokens, stream),
186 .ExtraAlignQualifier => |*x| return x.render(tokens, stream),
187 .ExtraConstQualifier => |*x| return x.render(tokens, stream),
188 .ExtraVolatileQualifier => |*x| return x.render(tokens, stream),
189 .ExtraAllowZeroQualifier => |*x| return x.render(tokens, stream),
190 .ExpectedTypeExpr => |*x| return x.render(tokens, stream),
191 .ExpectedPrimaryTypeExpr => |*x| return x.render(tokens, stream),
192 .ExpectedParamType => |*x| return x.render(tokens, stream),
193 .ExpectedExpr => |*x| return x.render(tokens, stream),
194 .ExpectedPrimaryExpr => |*x| return x.render(tokens, stream),
195 .ExpectedToken => |*x| return x.render(tokens, stream),
196 .ExpectedCommaOrEnd => |*x| return x.render(tokens, stream),
197 .ExpectedParamList => |*x| return x.render(tokens, stream),
198 .ExpectedPayload => |*x| return x.render(tokens, stream),
199 .ExpectedBlockOrAssignment => |*x| return x.render(tokens, stream),
200 .ExpectedBlockOrExpression => |*x| return x.render(tokens, stream),
201 .ExpectedExprOrAssignment => |*x| return x.render(tokens, stream),
202 .ExpectedPrefixExpr => |*x| return x.render(tokens, stream),
203 .ExpectedLoopExpr => |*x| return x.render(tokens, stream),
204 .ExpectedDerefOrUnwrap => |*x| return x.render(tokens, stream),
205 .ExpectedSuffixOp => |*x| return x.render(tokens, stream),
207206 }
208207 }
209208
210209 pub fn loc(self: *const Error) TokenIndex {
211210 switch (self.*) {
212 // TODO https://github.com/ziglang/zig/issues/683
213 @TagType(Error).InvalidToken => |x| return x.token,
214 @TagType(Error).ExpectedContainerMembers => |x| return x.token,
215 @TagType(Error).ExpectedStringLiteral => |x| return x.token,
216 @TagType(Error).ExpectedIntegerLiteral => |x| return x.token,
217 @TagType(Error).ExpectedPubItem => |x| return x.token,
218 @TagType(Error).ExpectedIdentifier => |x| return x.token,
219 @TagType(Error).ExpectedStatement => |x| return x.token,
220 @TagType(Error).ExpectedVarDeclOrFn => |x| return x.token,
221 @TagType(Error).ExpectedVarDecl => |x| return x.token,
222 @TagType(Error).ExpectedReturnType => |x| return x.token,
223 @TagType(Error).ExpectedAggregateKw => |x| return x.token,
224 @TagType(Error).UnattachedDocComment => |x| return x.token,
225 @TagType(Error).ExpectedEqOrSemi => |x| return x.token,
226 @TagType(Error).ExpectedSemiOrLBrace => |x| return x.token,
227 @TagType(Error).ExpectedSemiOrElse => |x| return x.token,
228 @TagType(Error).ExpectedLabelOrLBrace => |x| return x.token,
229 @TagType(Error).ExpectedLBrace => |x| return x.token,
230 @TagType(Error).ExpectedColonOrRParen => |x| return x.token,
231 @TagType(Error).ExpectedLabelable => |x| return x.token,
232 @TagType(Error).ExpectedInlinable => |x| return x.token,
233 @TagType(Error).ExpectedAsmOutputReturnOrType => |x| return x.token,
234 @TagType(Error).ExpectedCall => |x| return x.node.firstToken(),
235 @TagType(Error).ExpectedCallOrFnProto => |x| return x.node.firstToken(),
236 @TagType(Error).ExpectedSliceOrRBracket => |x| return x.token,
237 @TagType(Error).ExtraAlignQualifier => |x| return x.token,
238 @TagType(Error).ExtraConstQualifier => |x| return x.token,
239 @TagType(Error).ExtraVolatileQualifier => |x| return x.token,
240 @TagType(Error).ExtraAllowZeroQualifier => |x| return x.token,
241 @TagType(Error).ExpectedTypeExpr => |x| return x.token,
242 @TagType(Error).ExpectedPrimaryTypeExpr => |x| return x.token,
243 @TagType(Error).ExpectedParamType => |x| return x.token,
244 @TagType(Error).ExpectedExpr => |x| return x.token,
245 @TagType(Error).ExpectedPrimaryExpr => |x| return x.token,
246 @TagType(Error).ExpectedToken => |x| return x.token,
247 @TagType(Error).ExpectedCommaOrEnd => |x| return x.token,
248 @TagType(Error).ExpectedParamList => |x| return x.token,
249 @TagType(Error).ExpectedPayload => |x| return x.token,
250 @TagType(Error).ExpectedBlockOrAssignment => |x| return x.token,
251 @TagType(Error).ExpectedBlockOrExpression => |x| return x.token,
252 @TagType(Error).ExpectedExprOrAssignment => |x| return x.token,
253 @TagType(Error).ExpectedPrefixExpr => |x| return x.token,
254 @TagType(Error).ExpectedLoopExpr => |x| return x.token,
255 @TagType(Error).ExpectedDerefOrUnwrap => |x| return x.token,
256 @TagType(Error).ExpectedSuffixOp => |x| return x.token,
211 .InvalidToken => |x| return x.token,
212 .ExpectedContainerMembers => |x| return x.token,
213 .ExpectedStringLiteral => |x| return x.token,
214 .ExpectedIntegerLiteral => |x| return x.token,
215 .ExpectedPubItem => |x| return x.token,
216 .ExpectedIdentifier => |x| return x.token,
217 .ExpectedStatement => |x| return x.token,
218 .ExpectedVarDeclOrFn => |x| return x.token,
219 .ExpectedVarDecl => |x| return x.token,
220 .ExpectedReturnType => |x| return x.token,
221 .ExpectedAggregateKw => |x| return x.token,
222 .UnattachedDocComment => |x| return x.token,
223 .ExpectedEqOrSemi => |x| return x.token,
224 .ExpectedSemiOrLBrace => |x| return x.token,
225 .ExpectedSemiOrElse => |x| return x.token,
226 .ExpectedLabelOrLBrace => |x| return x.token,
227 .ExpectedLBrace => |x| return x.token,
228 .ExpectedColonOrRParen => |x| return x.token,
229 .ExpectedLabelable => |x| return x.token,
230 .ExpectedInlinable => |x| return x.token,
231 .ExpectedAsmOutputReturnOrType => |x| return x.token,
232 .ExpectedCall => |x| return x.node.firstToken(),
233 .ExpectedCallOrFnProto => |x| return x.node.firstToken(),
234 .ExpectedSliceOrRBracket => |x| return x.token,
235 .ExtraAlignQualifier => |x| return x.token,
236 .ExtraConstQualifier => |x| return x.token,
237 .ExtraVolatileQualifier => |x| return x.token,
238 .ExtraAllowZeroQualifier => |x| return x.token,
239 .ExpectedTypeExpr => |x| return x.token,
240 .ExpectedPrimaryTypeExpr => |x| return x.token,
241 .ExpectedParamType => |x| return x.token,
242 .ExpectedExpr => |x| return x.token,
243 .ExpectedPrimaryExpr => |x| return x.token,
244 .ExpectedToken => |x| return x.token,
245 .ExpectedCommaOrEnd => |x| return x.token,
246 .ExpectedParamList => |x| return x.token,
247 .ExpectedPayload => |x| return x.token,
248 .ExpectedBlockOrAssignment => |x| return x.token,
249 .ExpectedBlockOrExpression => |x| return x.token,
250 .ExpectedExprOrAssignment => |x| return x.token,
251 .ExpectedPrefixExpr => |x| return x.token,
252 .ExpectedLoopExpr => |x| return x.token,
253 .ExpectedDerefOrUnwrap => |x| return x.token,
254 .ExpectedSuffixOp => |x| return x.token,
257255 }
258256 }
259257
......@@ -320,8 +318,19 @@ pub const Error = union(enum) {
320318 expected_id: Token.Id,
321319
322320 pub fn render(self: *const ExpectedToken, tokens: *Tree.TokenList, stream: var) !void {
323 const token_name = @tagName(tokens.at(self.token).id);
324 return stream.print("expected {}, found {}", @tagName(self.expected_id), token_name);
321 const found_token = tokens.at(self.token);
322 switch (found_token.id) {
323 .Invalid_ampersands => {
324 return stream.print("`&&` is invalid. Note that `and` is boolean AND.");
325 },
326 .Invalid => {
327 return stream.print("expected {}, found invalid bytes", @tagName(self.expected_id));
328 },
329 else => {
330 const token_name = @tagName(found_token.id);
331 return stream.print("expected {}, found {}", @tagName(self.expected_id), token_name);
332 },
333 }
325334 }
326335 };
327336
......@@ -1708,15 +1717,15 @@ pub const Node = struct {
17081717 i -= 1;
17091718
17101719 switch (self.op) {
1711 @TagType(Op).Call => |*call_info| {
1720 .Call => |*call_info| {
17121721 if (i < call_info.params.len) return call_info.params.at(i).*;
17131722 i -= call_info.params.len;
17141723 },
1715 Op.ArrayAccess => |index_expr| {
1724 .ArrayAccess => |index_expr| {
17161725 if (i < 1) return index_expr;
17171726 i -= 1;
17181727 },
1719 @TagType(Op).Slice => |range| {
1728 .Slice => |range| {
17201729 if (i < 1) return range.start;
17211730 i -= 1;
17221731
......@@ -1725,16 +1734,16 @@ pub const Node = struct {
17251734 i -= 1;
17261735 }
17271736 },
1728 Op.ArrayInitializer => |*exprs| {
1737 .ArrayInitializer => |*exprs| {
17291738 if (i < exprs.len) return exprs.at(i).*;
17301739 i -= exprs.len;
17311740 },
1732 Op.StructInitializer => |*fields| {
1741 .StructInitializer => |*fields| {
17331742 if (i < fields.len) return fields.at(i).*;
17341743 i -= fields.len;
17351744 },
1736 Op.UnwrapOptional,
1737 Op.Deref,
1745 .UnwrapOptional,
1746 .Deref,
17381747 => {},
17391748 }
17401749
......@@ -1743,7 +1752,7 @@ pub const Node = struct {
17431752
17441753 pub fn firstToken(self: *const SuffixOp) TokenIndex {
17451754 switch (self.op) {
1746 @TagType(Op).Call => |*call_info| if (call_info.async_attr) |async_attr| return async_attr.firstToken(),
1755 .Call => |*call_info| if (call_info.async_attr) |async_attr| return async_attr.firstToken(),
17471756 else => {},
17481757 }
17491758 return self.lhs.firstToken();
std/zig/parse.zig+1-1
......@@ -774,7 +774,7 @@ fn parseBoolAndExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
774774 arena,
775775 it,
776776 tree,
777 SimpleBinOpParseFn(.Keyword_and, Node.InfixOp.Op.BoolAnd),
777 SimpleBinOpParseFn(.Keyword_and, .BoolAnd),
778778 parseCompareExpr,
779779 .Infinitely,
780780 );
std/zig/tokenizer.zig+6
......@@ -77,6 +77,7 @@ pub const Token = struct {
7777
7878 pub const Id = enum {
7979 Invalid,
80 Invalid_ampersands,
8081 Identifier,
8182 StringLiteral,
8283 MultilineStringLiteralLine,
......@@ -484,6 +485,11 @@ pub const Tokenizer = struct {
484485 },
485486
486487 State.Ampersand => switch (c) {
488 '&' => {
489 result.id = Token.Id.Invalid_ampersands;
490 self.index += 1;
491 break;
492 },
487493 '=' => {
488494 result.id = Token.Id.AmpersandEqual;
489495 self.index += 1;