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...@@ -742,101 +742,101 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: var, source_token: Tok
742 const token = tokenizer.next();742 const token = tokenizer.next();
743 try writeEscaped(out, src[index..token.start]);743 try writeEscaped(out, src[index..token.start]);
744 switch (token.id) {744 switch (token.id) {
745 std.zig.Token.Id.Eof => break,745 .Eof => break,
746746
747 std.zig.Token.Id.Keyword_align,747 .Keyword_align,
748 std.zig.Token.Id.Keyword_and,748 .Keyword_and,
749 std.zig.Token.Id.Keyword_asm,749 .Keyword_asm,
750 std.zig.Token.Id.Keyword_async,750 .Keyword_async,
751 std.zig.Token.Id.Keyword_await,751 .Keyword_await,
752 std.zig.Token.Id.Keyword_break,752 .Keyword_break,
753 std.zig.Token.Id.Keyword_cancel,753 .Keyword_cancel,
754 std.zig.Token.Id.Keyword_catch,754 .Keyword_catch,
755 std.zig.Token.Id.Keyword_comptime,755 .Keyword_comptime,
756 std.zig.Token.Id.Keyword_const,756 .Keyword_const,
757 std.zig.Token.Id.Keyword_continue,757 .Keyword_continue,
758 std.zig.Token.Id.Keyword_defer,758 .Keyword_defer,
759 std.zig.Token.Id.Keyword_else,759 .Keyword_else,
760 std.zig.Token.Id.Keyword_enum,760 .Keyword_enum,
761 std.zig.Token.Id.Keyword_errdefer,761 .Keyword_errdefer,
762 std.zig.Token.Id.Keyword_error,762 .Keyword_error,
763 std.zig.Token.Id.Keyword_export,763 .Keyword_export,
764 std.zig.Token.Id.Keyword_extern,764 .Keyword_extern,
765 std.zig.Token.Id.Keyword_for,765 .Keyword_for,
766 std.zig.Token.Id.Keyword_if,766 .Keyword_if,
767 std.zig.Token.Id.Keyword_inline,767 .Keyword_inline,
768 std.zig.Token.Id.Keyword_nakedcc,768 .Keyword_nakedcc,
769 std.zig.Token.Id.Keyword_noalias,769 .Keyword_noalias,
770 std.zig.Token.Id.Keyword_or,770 .Keyword_or,
771 std.zig.Token.Id.Keyword_orelse,771 .Keyword_orelse,
772 std.zig.Token.Id.Keyword_packed,772 .Keyword_packed,
773 std.zig.Token.Id.Keyword_promise,773 .Keyword_promise,
774 std.zig.Token.Id.Keyword_pub,774 .Keyword_pub,
775 std.zig.Token.Id.Keyword_resume,775 .Keyword_resume,
776 std.zig.Token.Id.Keyword_return,776 .Keyword_return,
777 std.zig.Token.Id.Keyword_linksection,777 .Keyword_linksection,
778 std.zig.Token.Id.Keyword_stdcallcc,778 .Keyword_stdcallcc,
779 std.zig.Token.Id.Keyword_struct,779 .Keyword_struct,
780 std.zig.Token.Id.Keyword_suspend,780 .Keyword_suspend,
781 std.zig.Token.Id.Keyword_switch,781 .Keyword_switch,
782 std.zig.Token.Id.Keyword_test,782 .Keyword_test,
783 std.zig.Token.Id.Keyword_threadlocal,783 .Keyword_threadlocal,
784 std.zig.Token.Id.Keyword_try,784 .Keyword_try,
785 std.zig.Token.Id.Keyword_union,785 .Keyword_union,
786 std.zig.Token.Id.Keyword_unreachable,786 .Keyword_unreachable,
787 std.zig.Token.Id.Keyword_usingnamespace,787 .Keyword_usingnamespace,
788 std.zig.Token.Id.Keyword_var,788 .Keyword_var,
789 std.zig.Token.Id.Keyword_volatile,789 .Keyword_volatile,
790 std.zig.Token.Id.Keyword_allowzero,790 .Keyword_allowzero,
791 std.zig.Token.Id.Keyword_while,791 .Keyword_while,
792 => {792 => {
793 try out.write("<span class=\"tok-kw\">");793 try out.write("<span class=\"tok-kw\">");
794 try writeEscaped(out, src[token.start..token.end]);794 try writeEscaped(out, src[token.start..token.end]);
795 try out.write("</span>");795 try out.write("</span>");
796 },796 },
797797
798 std.zig.Token.Id.Keyword_fn => {798 .Keyword_fn => {
799 try out.write("<span class=\"tok-kw\">");799 try out.write("<span class=\"tok-kw\">");
800 try writeEscaped(out, src[token.start..token.end]);800 try writeEscaped(out, src[token.start..token.end]);
801 try out.write("</span>");801 try out.write("</span>");
802 next_tok_is_fn = true;802 next_tok_is_fn = true;
803 },803 },
804804
805 std.zig.Token.Id.Keyword_undefined,805 .Keyword_undefined,
806 std.zig.Token.Id.Keyword_null,806 .Keyword_null,
807 std.zig.Token.Id.Keyword_true,807 .Keyword_true,
808 std.zig.Token.Id.Keyword_false,808 .Keyword_false,
809 => {809 => {
810 try out.write("<span class=\"tok-null\">");810 try out.write("<span class=\"tok-null\">");
811 try writeEscaped(out, src[token.start..token.end]);811 try writeEscaped(out, src[token.start..token.end]);
812 try out.write("</span>");812 try out.write("</span>");
813 },813 },
814814
815 std.zig.Token.Id.StringLiteral,815 .StringLiteral,
816 std.zig.Token.Id.MultilineStringLiteralLine,816 .MultilineStringLiteralLine,
817 std.zig.Token.Id.CharLiteral,817 .CharLiteral,
818 => {818 => {
819 try out.write("<span class=\"tok-str\">");819 try out.write("<span class=\"tok-str\">");
820 try writeEscaped(out, src[token.start..token.end]);820 try writeEscaped(out, src[token.start..token.end]);
821 try out.write("</span>");821 try out.write("</span>");
822 },822 },
823823
824 std.zig.Token.Id.Builtin => {824 .Builtin => {
825 try out.write("<span class=\"tok-builtin\">");825 try out.write("<span class=\"tok-builtin\">");
826 try writeEscaped(out, src[token.start..token.end]);826 try writeEscaped(out, src[token.start..token.end]);
827 try out.write("</span>");827 try out.write("</span>");
828 },828 },
829829
830 std.zig.Token.Id.LineComment,830 .LineComment,
831 std.zig.Token.Id.DocComment,831 .DocComment,
832 std.zig.Token.Id.ShebangLine,832 .ShebangLine,
833 => {833 => {
834 try out.write("<span class=\"tok-comment\">");834 try out.write("<span class=\"tok-comment\">");
835 try writeEscaped(out, src[token.start..token.end]);835 try writeEscaped(out, src[token.start..token.end]);
836 try out.write("</span>");836 try out.write("</span>");
837 },837 },
838838
839 std.zig.Token.Id.Identifier => {839 .Identifier => {
840 if (prev_tok_was_fn) {840 if (prev_tok_was_fn) {
841 try out.write("<span class=\"tok-fn\">");841 try out.write("<span class=\"tok-fn\">");
842 try writeEscaped(out, src[token.start..token.end]);842 try writeEscaped(out, src[token.start..token.end]);
...@@ -864,72 +864,72 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: var, source_token: Tok...@@ -864,72 +864,72 @@ fn tokenizeAndPrintRaw(docgen_tokenizer: *Tokenizer, out: var, source_token: Tok
864 }864 }
865 },865 },
866866
867 std.zig.Token.Id.IntegerLiteral,867 .IntegerLiteral,
868 std.zig.Token.Id.FloatLiteral,868 .FloatLiteral,
869 => {869 => {
870 try out.write("<span class=\"tok-number\">");870 try out.write("<span class=\"tok-number\">");
871 try writeEscaped(out, src[token.start..token.end]);871 try writeEscaped(out, src[token.start..token.end]);
872 try out.write("</span>");872 try out.write("</span>");
873 },873 },
874874
875 std.zig.Token.Id.Bang,875 .Bang,
876 std.zig.Token.Id.Pipe,876 .Pipe,
877 std.zig.Token.Id.PipePipe,877 .PipePipe,
878 std.zig.Token.Id.PipeEqual,878 .PipeEqual,
879 std.zig.Token.Id.Equal,879 .Equal,
880 std.zig.Token.Id.EqualEqual,880 .EqualEqual,
881 std.zig.Token.Id.EqualAngleBracketRight,881 .EqualAngleBracketRight,
882 std.zig.Token.Id.BangEqual,882 .BangEqual,
883 std.zig.Token.Id.LParen,883 .LParen,
884 std.zig.Token.Id.RParen,884 .RParen,
885 std.zig.Token.Id.Semicolon,885 .Semicolon,
886 std.zig.Token.Id.Percent,886 .Percent,
887 std.zig.Token.Id.PercentEqual,887 .PercentEqual,
888 std.zig.Token.Id.LBrace,888 .LBrace,
889 std.zig.Token.Id.RBrace,889 .RBrace,
890 std.zig.Token.Id.LBracket,890 .LBracket,
891 std.zig.Token.Id.RBracket,891 .RBracket,
892 std.zig.Token.Id.Period,892 .Period,
893 std.zig.Token.Id.Ellipsis2,893 .Ellipsis2,
894 std.zig.Token.Id.Ellipsis3,894 .Ellipsis3,
895 std.zig.Token.Id.Caret,895 .Caret,
896 std.zig.Token.Id.CaretEqual,896 .CaretEqual,
897 std.zig.Token.Id.Plus,897 .Plus,
898 std.zig.Token.Id.PlusPlus,898 .PlusPlus,
899 std.zig.Token.Id.PlusEqual,899 .PlusEqual,
900 std.zig.Token.Id.PlusPercent,900 .PlusPercent,
901 std.zig.Token.Id.PlusPercentEqual,901 .PlusPercentEqual,
902 std.zig.Token.Id.Minus,902 .Minus,
903 std.zig.Token.Id.MinusEqual,903 .MinusEqual,
904 std.zig.Token.Id.MinusPercent,904 .MinusPercent,
905 std.zig.Token.Id.MinusPercentEqual,905 .MinusPercentEqual,
906 std.zig.Token.Id.Asterisk,906 .Asterisk,
907 std.zig.Token.Id.AsteriskEqual,907 .AsteriskEqual,
908 std.zig.Token.Id.AsteriskAsterisk,908 .AsteriskAsterisk,
909 std.zig.Token.Id.AsteriskPercent,909 .AsteriskPercent,
910 std.zig.Token.Id.AsteriskPercentEqual,910 .AsteriskPercentEqual,
911 std.zig.Token.Id.Arrow,911 .Arrow,
912 std.zig.Token.Id.Colon,912 .Colon,
913 std.zig.Token.Id.Slash,913 .Slash,
914 std.zig.Token.Id.SlashEqual,914 .SlashEqual,
915 std.zig.Token.Id.Comma,915 .Comma,
916 std.zig.Token.Id.Ampersand,916 .Ampersand,
917 std.zig.Token.Id.AmpersandEqual,917 .AmpersandEqual,
918 std.zig.Token.Id.QuestionMark,918 .QuestionMark,
919 std.zig.Token.Id.AngleBracketLeft,919 .AngleBracketLeft,
920 std.zig.Token.Id.AngleBracketLeftEqual,920 .AngleBracketLeftEqual,
921 std.zig.Token.Id.AngleBracketAngleBracketLeft,921 .AngleBracketAngleBracketLeft,
922 std.zig.Token.Id.AngleBracketAngleBracketLeftEqual,922 .AngleBracketAngleBracketLeftEqual,
923 std.zig.Token.Id.AngleBracketRight,923 .AngleBracketRight,
924 std.zig.Token.Id.AngleBracketRightEqual,924 .AngleBracketRightEqual,
925 std.zig.Token.Id.AngleBracketAngleBracketRight,925 .AngleBracketAngleBracketRight,
926 std.zig.Token.Id.AngleBracketAngleBracketRightEqual,926 .AngleBracketAngleBracketRightEqual,
927 std.zig.Token.Id.Tilde,927 .Tilde,
928 std.zig.Token.Id.BracketStarBracket,928 .BracketStarBracket,
929 std.zig.Token.Id.BracketStarCBracket,929 .BracketStarCBracket,
930 => try writeEscaped(out, src[token.start..token.end]),930 => try writeEscaped(out, src[token.start..token.end]),
931931
932 std.zig.Token.Id.Invalid => return parseError(932 .Invalid, .Invalid_ampersands => return parseError(
933 docgen_tokenizer,933 docgen_tokenizer,
934 source_token,934 source_token,
935 "syntax error",935 "syntax error",
std/zig/ast.zig+109-100
...@@ -159,101 +159,99 @@ pub const Error = union(enum) {...@@ -159,101 +159,99 @@ pub const Error = union(enum) {
159159
160 pub fn render(self: *const Error, tokens: *Tree.TokenList, stream: var) !void {160 pub fn render(self: *const Error, tokens: *Tree.TokenList, stream: var) !void {
161 switch (self.*) {161 switch (self.*) {
162 // TODO https://github.com/ziglang/zig/issues/683162 .InvalidToken => |*x| return x.render(tokens, stream),
163 @TagType(Error).InvalidToken => |*x| return x.render(tokens, stream),163 .ExpectedContainerMembers => |*x| return x.render(tokens, stream),
164 @TagType(Error).ExpectedContainerMembers => |*x| return x.render(tokens, stream),164 .ExpectedStringLiteral => |*x| return x.render(tokens, stream),
165 @TagType(Error).ExpectedStringLiteral => |*x| return x.render(tokens, stream),165 .ExpectedIntegerLiteral => |*x| return x.render(tokens, stream),
166 @TagType(Error).ExpectedIntegerLiteral => |*x| return x.render(tokens, stream),166 .ExpectedPubItem => |*x| return x.render(tokens, stream),
167 @TagType(Error).ExpectedPubItem => |*x| return x.render(tokens, stream),167 .ExpectedIdentifier => |*x| return x.render(tokens, stream),
168 @TagType(Error).ExpectedIdentifier => |*x| return x.render(tokens, stream),168 .ExpectedStatement => |*x| return x.render(tokens, stream),
169 @TagType(Error).ExpectedStatement => |*x| return x.render(tokens, stream),169 .ExpectedVarDeclOrFn => |*x| return x.render(tokens, stream),
170 @TagType(Error).ExpectedVarDeclOrFn => |*x| return x.render(tokens, stream),170 .ExpectedVarDecl => |*x| return x.render(tokens, stream),
171 @TagType(Error).ExpectedVarDecl => |*x| return x.render(tokens, stream),171 .ExpectedReturnType => |*x| return x.render(tokens, stream),
172 @TagType(Error).ExpectedReturnType => |*x| return x.render(tokens, stream),172 .ExpectedAggregateKw => |*x| return x.render(tokens, stream),
173 @TagType(Error).ExpectedAggregateKw => |*x| return x.render(tokens, stream),173 .UnattachedDocComment => |*x| return x.render(tokens, stream),
174 @TagType(Error).UnattachedDocComment => |*x| return x.render(tokens, stream),174 .ExpectedEqOrSemi => |*x| return x.render(tokens, stream),
175 @TagType(Error).ExpectedEqOrSemi => |*x| return x.render(tokens, stream),175 .ExpectedSemiOrLBrace => |*x| return x.render(tokens, stream),
176 @TagType(Error).ExpectedSemiOrLBrace => |*x| return x.render(tokens, stream),176 .ExpectedSemiOrElse => |*x| return x.render(tokens, stream),
177 @TagType(Error).ExpectedSemiOrElse => |*x| return x.render(tokens, stream),177 .ExpectedLabelOrLBrace => |*x| return x.render(tokens, stream),
178 @TagType(Error).ExpectedLabelOrLBrace => |*x| return x.render(tokens, stream),178 .ExpectedLBrace => |*x| return x.render(tokens, stream),
179 @TagType(Error).ExpectedLBrace => |*x| return x.render(tokens, stream),179 .ExpectedColonOrRParen => |*x| return x.render(tokens, stream),
180 @TagType(Error).ExpectedColonOrRParen => |*x| return x.render(tokens, stream),180 .ExpectedLabelable => |*x| return x.render(tokens, stream),
181 @TagType(Error).ExpectedLabelable => |*x| return x.render(tokens, stream),181 .ExpectedInlinable => |*x| return x.render(tokens, stream),
182 @TagType(Error).ExpectedInlinable => |*x| return x.render(tokens, stream),182 .ExpectedAsmOutputReturnOrType => |*x| return x.render(tokens, stream),
183 @TagType(Error).ExpectedAsmOutputReturnOrType => |*x| return x.render(tokens, stream),183 .ExpectedCall => |*x| return x.render(tokens, stream),
184 @TagType(Error).ExpectedCall => |*x| return x.render(tokens, stream),184 .ExpectedCallOrFnProto => |*x| return x.render(tokens, stream),
185 @TagType(Error).ExpectedCallOrFnProto => |*x| return x.render(tokens, stream),185 .ExpectedSliceOrRBracket => |*x| return x.render(tokens, stream),
186 @TagType(Error).ExpectedSliceOrRBracket => |*x| return x.render(tokens, stream),186 .ExtraAlignQualifier => |*x| return x.render(tokens, stream),
187 @TagType(Error).ExtraAlignQualifier => |*x| return x.render(tokens, stream),187 .ExtraConstQualifier => |*x| return x.render(tokens, stream),
188 @TagType(Error).ExtraConstQualifier => |*x| return x.render(tokens, stream),188 .ExtraVolatileQualifier => |*x| return x.render(tokens, stream),
189 @TagType(Error).ExtraVolatileQualifier => |*x| return x.render(tokens, stream),189 .ExtraAllowZeroQualifier => |*x| return x.render(tokens, stream),
190 @TagType(Error).ExtraAllowZeroQualifier => |*x| return x.render(tokens, stream),190 .ExpectedTypeExpr => |*x| return x.render(tokens, stream),
191 @TagType(Error).ExpectedTypeExpr => |*x| return x.render(tokens, stream),191 .ExpectedPrimaryTypeExpr => |*x| return x.render(tokens, stream),
192 @TagType(Error).ExpectedPrimaryTypeExpr => |*x| return x.render(tokens, stream),192 .ExpectedParamType => |*x| return x.render(tokens, stream),
193 @TagType(Error).ExpectedParamType => |*x| return x.render(tokens, stream),193 .ExpectedExpr => |*x| return x.render(tokens, stream),
194 @TagType(Error).ExpectedExpr => |*x| return x.render(tokens, stream),194 .ExpectedPrimaryExpr => |*x| return x.render(tokens, stream),
195 @TagType(Error).ExpectedPrimaryExpr => |*x| return x.render(tokens, stream),195 .ExpectedToken => |*x| return x.render(tokens, stream),
196 @TagType(Error).ExpectedToken => |*x| return x.render(tokens, stream),196 .ExpectedCommaOrEnd => |*x| return x.render(tokens, stream),
197 @TagType(Error).ExpectedCommaOrEnd => |*x| return x.render(tokens, stream),197 .ExpectedParamList => |*x| return x.render(tokens, stream),
198 @TagType(Error).ExpectedParamList => |*x| return x.render(tokens, stream),198 .ExpectedPayload => |*x| return x.render(tokens, stream),
199 @TagType(Error).ExpectedPayload => |*x| return x.render(tokens, stream),199 .ExpectedBlockOrAssignment => |*x| return x.render(tokens, stream),
200 @TagType(Error).ExpectedBlockOrAssignment => |*x| return x.render(tokens, stream),200 .ExpectedBlockOrExpression => |*x| return x.render(tokens, stream),
201 @TagType(Error).ExpectedBlockOrExpression => |*x| return x.render(tokens, stream),201 .ExpectedExprOrAssignment => |*x| return x.render(tokens, stream),
202 @TagType(Error).ExpectedExprOrAssignment => |*x| return x.render(tokens, stream),202 .ExpectedPrefixExpr => |*x| return x.render(tokens, stream),
203 @TagType(Error).ExpectedPrefixExpr => |*x| return x.render(tokens, stream),203 .ExpectedLoopExpr => |*x| return x.render(tokens, stream),
204 @TagType(Error).ExpectedLoopExpr => |*x| return x.render(tokens, stream),204 .ExpectedDerefOrUnwrap => |*x| return x.render(tokens, stream),
205 @TagType(Error).ExpectedDerefOrUnwrap => |*x| return x.render(tokens, stream),205 .ExpectedSuffixOp => |*x| return x.render(tokens, stream),
206 @TagType(Error).ExpectedSuffixOp => |*x| return x.render(tokens, stream),
207 }206 }
208 }207 }
209208
210 pub fn loc(self: *const Error) TokenIndex {209 pub fn loc(self: *const Error) TokenIndex {
211 switch (self.*) {210 switch (self.*) {
212 // TODO https://github.com/ziglang/zig/issues/683211 .InvalidToken => |x| return x.token,
213 @TagType(Error).InvalidToken => |x| return x.token,212 .ExpectedContainerMembers => |x| return x.token,
214 @TagType(Error).ExpectedContainerMembers => |x| return x.token,213 .ExpectedStringLiteral => |x| return x.token,
215 @TagType(Error).ExpectedStringLiteral => |x| return x.token,214 .ExpectedIntegerLiteral => |x| return x.token,
216 @TagType(Error).ExpectedIntegerLiteral => |x| return x.token,215 .ExpectedPubItem => |x| return x.token,
217 @TagType(Error).ExpectedPubItem => |x| return x.token,216 .ExpectedIdentifier => |x| return x.token,
218 @TagType(Error).ExpectedIdentifier => |x| return x.token,217 .ExpectedStatement => |x| return x.token,
219 @TagType(Error).ExpectedStatement => |x| return x.token,218 .ExpectedVarDeclOrFn => |x| return x.token,
220 @TagType(Error).ExpectedVarDeclOrFn => |x| return x.token,219 .ExpectedVarDecl => |x| return x.token,
221 @TagType(Error).ExpectedVarDecl => |x| return x.token,220 .ExpectedReturnType => |x| return x.token,
222 @TagType(Error).ExpectedReturnType => |x| return x.token,221 .ExpectedAggregateKw => |x| return x.token,
223 @TagType(Error).ExpectedAggregateKw => |x| return x.token,222 .UnattachedDocComment => |x| return x.token,
224 @TagType(Error).UnattachedDocComment => |x| return x.token,223 .ExpectedEqOrSemi => |x| return x.token,
225 @TagType(Error).ExpectedEqOrSemi => |x| return x.token,224 .ExpectedSemiOrLBrace => |x| return x.token,
226 @TagType(Error).ExpectedSemiOrLBrace => |x| return x.token,225 .ExpectedSemiOrElse => |x| return x.token,
227 @TagType(Error).ExpectedSemiOrElse => |x| return x.token,226 .ExpectedLabelOrLBrace => |x| return x.token,
228 @TagType(Error).ExpectedLabelOrLBrace => |x| return x.token,227 .ExpectedLBrace => |x| return x.token,
229 @TagType(Error).ExpectedLBrace => |x| return x.token,228 .ExpectedColonOrRParen => |x| return x.token,
230 @TagType(Error).ExpectedColonOrRParen => |x| return x.token,229 .ExpectedLabelable => |x| return x.token,
231 @TagType(Error).ExpectedLabelable => |x| return x.token,230 .ExpectedInlinable => |x| return x.token,
232 @TagType(Error).ExpectedInlinable => |x| return x.token,231 .ExpectedAsmOutputReturnOrType => |x| return x.token,
233 @TagType(Error).ExpectedAsmOutputReturnOrType => |x| return x.token,232 .ExpectedCall => |x| return x.node.firstToken(),
234 @TagType(Error).ExpectedCall => |x| return x.node.firstToken(),233 .ExpectedCallOrFnProto => |x| return x.node.firstToken(),
235 @TagType(Error).ExpectedCallOrFnProto => |x| return x.node.firstToken(),234 .ExpectedSliceOrRBracket => |x| return x.token,
236 @TagType(Error).ExpectedSliceOrRBracket => |x| return x.token,235 .ExtraAlignQualifier => |x| return x.token,
237 @TagType(Error).ExtraAlignQualifier => |x| return x.token,236 .ExtraConstQualifier => |x| return x.token,
238 @TagType(Error).ExtraConstQualifier => |x| return x.token,237 .ExtraVolatileQualifier => |x| return x.token,
239 @TagType(Error).ExtraVolatileQualifier => |x| return x.token,238 .ExtraAllowZeroQualifier => |x| return x.token,
240 @TagType(Error).ExtraAllowZeroQualifier => |x| return x.token,239 .ExpectedTypeExpr => |x| return x.token,
241 @TagType(Error).ExpectedTypeExpr => |x| return x.token,240 .ExpectedPrimaryTypeExpr => |x| return x.token,
242 @TagType(Error).ExpectedPrimaryTypeExpr => |x| return x.token,241 .ExpectedParamType => |x| return x.token,
243 @TagType(Error).ExpectedParamType => |x| return x.token,242 .ExpectedExpr => |x| return x.token,
244 @TagType(Error).ExpectedExpr => |x| return x.token,243 .ExpectedPrimaryExpr => |x| return x.token,
245 @TagType(Error).ExpectedPrimaryExpr => |x| return x.token,244 .ExpectedToken => |x| return x.token,
246 @TagType(Error).ExpectedToken => |x| return x.token,245 .ExpectedCommaOrEnd => |x| return x.token,
247 @TagType(Error).ExpectedCommaOrEnd => |x| return x.token,246 .ExpectedParamList => |x| return x.token,
248 @TagType(Error).ExpectedParamList => |x| return x.token,247 .ExpectedPayload => |x| return x.token,
249 @TagType(Error).ExpectedPayload => |x| return x.token,248 .ExpectedBlockOrAssignment => |x| return x.token,
250 @TagType(Error).ExpectedBlockOrAssignment => |x| return x.token,249 .ExpectedBlockOrExpression => |x| return x.token,
251 @TagType(Error).ExpectedBlockOrExpression => |x| return x.token,250 .ExpectedExprOrAssignment => |x| return x.token,
252 @TagType(Error).ExpectedExprOrAssignment => |x| return x.token,251 .ExpectedPrefixExpr => |x| return x.token,
253 @TagType(Error).ExpectedPrefixExpr => |x| return x.token,252 .ExpectedLoopExpr => |x| return x.token,
254 @TagType(Error).ExpectedLoopExpr => |x| return x.token,253 .ExpectedDerefOrUnwrap => |x| return x.token,
255 @TagType(Error).ExpectedDerefOrUnwrap => |x| return x.token,254 .ExpectedSuffixOp => |x| return x.token,
256 @TagType(Error).ExpectedSuffixOp => |x| return x.token,
257 }255 }
258 }256 }
259257
...@@ -320,8 +318,19 @@ pub const Error = union(enum) {...@@ -320,8 +318,19 @@ pub const Error = union(enum) {
320 expected_id: Token.Id,318 expected_id: Token.Id,
321319
322 pub fn render(self: *const ExpectedToken, tokens: *Tree.TokenList, stream: var) !void {320 pub fn render(self: *const ExpectedToken, tokens: *Tree.TokenList, stream: var) !void {
323 const token_name = @tagName(tokens.at(self.token).id);321 const found_token = tokens.at(self.token);
324 return stream.print("expected {}, found {}", @tagName(self.expected_id), token_name);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 }
325 }334 }
326 };335 };
327336
...@@ -1708,15 +1717,15 @@ pub const Node = struct {...@@ -1708,15 +1717,15 @@ pub const Node = struct {
1708 i -= 1;1717 i -= 1;
17091718
1710 switch (self.op) {1719 switch (self.op) {
1711 @TagType(Op).Call => |*call_info| {1720 .Call => |*call_info| {
1712 if (i < call_info.params.len) return call_info.params.at(i).*;1721 if (i < call_info.params.len) return call_info.params.at(i).*;
1713 i -= call_info.params.len;1722 i -= call_info.params.len;
1714 },1723 },
1715 Op.ArrayAccess => |index_expr| {1724 .ArrayAccess => |index_expr| {
1716 if (i < 1) return index_expr;1725 if (i < 1) return index_expr;
1717 i -= 1;1726 i -= 1;
1718 },1727 },
1719 @TagType(Op).Slice => |range| {1728 .Slice => |range| {
1720 if (i < 1) return range.start;1729 if (i < 1) return range.start;
1721 i -= 1;1730 i -= 1;
17221731
...@@ -1725,16 +1734,16 @@ pub const Node = struct {...@@ -1725,16 +1734,16 @@ pub const Node = struct {
1725 i -= 1;1734 i -= 1;
1726 }1735 }
1727 },1736 },
1728 Op.ArrayInitializer => |*exprs| {1737 .ArrayInitializer => |*exprs| {
1729 if (i < exprs.len) return exprs.at(i).*;1738 if (i < exprs.len) return exprs.at(i).*;
1730 i -= exprs.len;1739 i -= exprs.len;
1731 },1740 },
1732 Op.StructInitializer => |*fields| {1741 .StructInitializer => |*fields| {
1733 if (i < fields.len) return fields.at(i).*;1742 if (i < fields.len) return fields.at(i).*;
1734 i -= fields.len;1743 i -= fields.len;
1735 },1744 },
1736 Op.UnwrapOptional,1745 .UnwrapOptional,
1737 Op.Deref,1746 .Deref,
1738 => {},1747 => {},
1739 }1748 }
17401749
...@@ -1743,7 +1752,7 @@ pub const Node = struct {...@@ -1743,7 +1752,7 @@ pub const Node = struct {
17431752
1744 pub fn firstToken(self: *const SuffixOp) TokenIndex {1753 pub fn firstToken(self: *const SuffixOp) TokenIndex {
1745 switch (self.op) {1754 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(),
1747 else => {},1756 else => {},
1748 }1757 }
1749 return self.lhs.firstToken();1758 return self.lhs.firstToken();
std/zig/parse.zig+1-1
...@@ -774,7 +774,7 @@ fn parseBoolAndExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node...@@ -774,7 +774,7 @@ fn parseBoolAndExpr(arena: *Allocator, it: *TokenIterator, tree: *Tree) !?*Node
774 arena,774 arena,
775 it,775 it,
776 tree,776 tree,
777 SimpleBinOpParseFn(.Keyword_and, Node.InfixOp.Op.BoolAnd),777 SimpleBinOpParseFn(.Keyword_and, .BoolAnd),
778 parseCompareExpr,778 parseCompareExpr,
779 .Infinitely,779 .Infinitely,
780 );780 );
std/zig/tokenizer.zig+6
...@@ -77,6 +77,7 @@ pub const Token = struct {...@@ -77,6 +77,7 @@ pub const Token = struct {
7777
78 pub const Id = enum {78 pub const Id = enum {
79 Invalid,79 Invalid,
80 Invalid_ampersands,
80 Identifier,81 Identifier,
81 StringLiteral,82 StringLiteral,
82 MultilineStringLiteralLine,83 MultilineStringLiteralLine,
...@@ -484,6 +485,11 @@ pub const Tokenizer = struct {...@@ -484,6 +485,11 @@ pub const Tokenizer = struct {
484 },485 },
485486
486 State.Ampersand => switch (c) {487 State.Ampersand => switch (c) {
488 '&' => {
489 result.id = Token.Id.Invalid_ampersands;
490 self.index += 1;
491 break;
492 },
487 '=' => {493 '=' => {
488 result.id = Token.Id.AmpersandEqual;494 result.id = Token.Id.AmpersandEqual;
489 self.index += 1;495 self.index += 1;