authorgravatar for matthew.h.borkowski@gmail.comMatthew Borkowski <matthew.h.borkowski@gmail.com> 2021-11-01 01:55:11-04:00
committergravatar for matthew.h.borkowski@gmail.comMatthew Borkowski <matthew.h.borkowski@gmail.com> 2021-11-01 05:42:19-04:00
log5760ba949fe3c2ab576e422dd3a74600f0e52d5c
treee45667f3ea1711130184ddcc9bedf426b09ca0b0
parente712f87a662e9f2711698bc5a74644a5b3b890f3

astgen.zig: simplify container functions by pulling out common processing of members

1 files changed, 136 insertions(+), 503 deletions(-)

src/AstGen.zig+136-503
......@@ -2998,9 +2998,9 @@ fn arrayTypeSentinel(gz: *GenZir, scope: *Scope, rl: ResultLoc, node: Ast.Node.I
29982998const WipMembers = struct {
29992999 payload: []u32,
30003000 decls_start: u32,
3001 decls_end: u32,
30013002 field_bits_start: u32,
30023003 fields_start: u32,
3003 decls_end: u32,
30043004 fields_end: u32,
30053005 decl_index: u32 = 0,
30063006 field_index: u32 = 0,
......@@ -3750,7 +3750,6 @@ fn structDeclInner(
37503750 const gpa = astgen.gpa;
37513751 const tree = astgen.tree;
37523752 const node_tags = tree.nodes.items(.tag);
3753 const node_datas = tree.nodes.items(.data);
37543753
37553754 var namespace: Scope.Namespace = .{
37563755 .parent = scope,
......@@ -3783,130 +3782,9 @@ fn structDeclInner(
37833782
37843783 var known_has_bits = false;
37853784 for (container_decl.ast.members) |member_node| {
3786 const member = switch (node_tags[member_node]) {
3787 .container_field_init => tree.containerFieldInit(member_node),
3788 .container_field_align => tree.containerFieldAlign(member_node),
3789 .container_field => tree.containerField(member_node),
3790
3791 .fn_decl => {
3792 const fn_proto = node_datas[member_node].lhs;
3793 const body = node_datas[member_node].rhs;
3794 switch (node_tags[fn_proto]) {
3795 .fn_proto_simple => {
3796 var params: [1]Ast.Node.Index = undefined;
3797 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProtoSimple(&params, fn_proto)) catch |err| switch (err) {
3798 error.OutOfMemory => return error.OutOfMemory,
3799 error.AnalysisFail => {},
3800 };
3801 continue;
3802 },
3803 .fn_proto_multi => {
3804 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProtoMulti(fn_proto)) catch |err| switch (err) {
3805 error.OutOfMemory => return error.OutOfMemory,
3806 error.AnalysisFail => {},
3807 };
3808 continue;
3809 },
3810 .fn_proto_one => {
3811 var params: [1]Ast.Node.Index = undefined;
3812 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProtoOne(&params, fn_proto)) catch |err| switch (err) {
3813 error.OutOfMemory => return error.OutOfMemory,
3814 error.AnalysisFail => {},
3815 };
3816 continue;
3817 },
3818 .fn_proto => {
3819 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProto(fn_proto)) catch |err| switch (err) {
3820 error.OutOfMemory => return error.OutOfMemory,
3821 error.AnalysisFail => {},
3822 };
3823 continue;
3824 },
3825 else => unreachable,
3826 }
3827 },
3828 .fn_proto_simple => {
3829 var params: [1]Ast.Node.Index = undefined;
3830 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProtoSimple(&params, member_node)) catch |err| switch (err) {
3831 error.OutOfMemory => return error.OutOfMemory,
3832 error.AnalysisFail => {},
3833 };
3834 continue;
3835 },
3836 .fn_proto_multi => {
3837 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProtoMulti(member_node)) catch |err| switch (err) {
3838 error.OutOfMemory => return error.OutOfMemory,
3839 error.AnalysisFail => {},
3840 };
3841 continue;
3842 },
3843 .fn_proto_one => {
3844 var params: [1]Ast.Node.Index = undefined;
3845 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProtoOne(&params, member_node)) catch |err| switch (err) {
3846 error.OutOfMemory => return error.OutOfMemory,
3847 error.AnalysisFail => {},
3848 };
3849 continue;
3850 },
3851 .fn_proto => {
3852 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProto(member_node)) catch |err| switch (err) {
3853 error.OutOfMemory => return error.OutOfMemory,
3854 error.AnalysisFail => {},
3855 };
3856 continue;
3857 },
3858
3859 .global_var_decl => {
3860 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.globalVarDecl(member_node)) catch |err| switch (err) {
3861 error.OutOfMemory => return error.OutOfMemory,
3862 error.AnalysisFail => {},
3863 };
3864 continue;
3865 },
3866 .local_var_decl => {
3867 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.localVarDecl(member_node)) catch |err| switch (err) {
3868 error.OutOfMemory => return error.OutOfMemory,
3869 error.AnalysisFail => {},
3870 };
3871 continue;
3872 },
3873 .simple_var_decl => {
3874 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.simpleVarDecl(member_node)) catch |err| switch (err) {
3875 error.OutOfMemory => return error.OutOfMemory,
3876 error.AnalysisFail => {},
3877 };
3878 continue;
3879 },
3880 .aligned_var_decl => {
3881 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.alignedVarDecl(member_node)) catch |err| switch (err) {
3882 error.OutOfMemory => return error.OutOfMemory,
3883 error.AnalysisFail => {},
3884 };
3885 continue;
3886 },
3887
3888 .@"comptime" => {
3889 astgen.comptimeDecl(gz, &namespace.base, &wip_members, member_node) catch |err| switch (err) {
3890 error.OutOfMemory => return error.OutOfMemory,
3891 error.AnalysisFail => {},
3892 };
3893 continue;
3894 },
3895 .@"usingnamespace" => {
3896 astgen.usingnamespaceDecl(gz, &namespace.base, &wip_members, member_node) catch |err| switch (err) {
3897 error.OutOfMemory => return error.OutOfMemory,
3898 error.AnalysisFail => {},
3899 };
3900 continue;
3901 },
3902 .test_decl => {
3903 astgen.testDecl(gz, &namespace.base, &wip_members, member_node) catch |err| switch (err) {
3904 error.OutOfMemory => return error.OutOfMemory,
3905 error.AnalysisFail => {},
3906 };
3907 continue;
3908 },
3909 else => unreachable,
3785 const member = switch (try containerMember(gz, &namespace.base, &wip_members, member_node)) {
3786 .decl => continue,
3787 .field => |field| field,
39103788 };
39113789
39123790 const field_name = try astgen.identAsString(member.ast.name_token);
......@@ -3943,7 +3821,6 @@ fn structDeclInner(
39433821 return astgen.failTok(comptime_token, "comptime field without default initialization value", .{});
39443822 }
39453823 }
3946 assert(wip_members.decl_index == decl_count and wip_members.field_index == field_count);
39473824
39483825 if (block_scope.instructions.items.len != 0) {
39493826 _ = try block_scope.addBreak(.break_inline, decl_inst, .void_value);
......@@ -3984,7 +3861,6 @@ fn unionDeclInner(
39843861 const gpa = astgen.gpa;
39853862 const tree = astgen.tree;
39863863 const node_tags = tree.nodes.items(.tag);
3987 const node_datas = tree.nodes.items(.data);
39883864
39893865 var namespace: Scope.Namespace = .{
39903866 .parent = scope,
......@@ -4021,130 +3897,9 @@ fn unionDeclInner(
40213897 defer wip_members.deinit(gpa);
40223898
40233899 for (members) |member_node| {
4024 const member = switch (node_tags[member_node]) {
4025 .container_field_init => tree.containerFieldInit(member_node),
4026 .container_field_align => tree.containerFieldAlign(member_node),
4027 .container_field => tree.containerField(member_node),
4028
4029 .fn_decl => {
4030 const fn_proto = node_datas[member_node].lhs;
4031 const body = node_datas[member_node].rhs;
4032 switch (node_tags[fn_proto]) {
4033 .fn_proto_simple => {
4034 var params: [1]Ast.Node.Index = undefined;
4035 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProtoSimple(&params, fn_proto)) catch |err| switch (err) {
4036 error.OutOfMemory => return error.OutOfMemory,
4037 error.AnalysisFail => {},
4038 };
4039 continue;
4040 },
4041 .fn_proto_multi => {
4042 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProtoMulti(fn_proto)) catch |err| switch (err) {
4043 error.OutOfMemory => return error.OutOfMemory,
4044 error.AnalysisFail => {},
4045 };
4046 continue;
4047 },
4048 .fn_proto_one => {
4049 var params: [1]Ast.Node.Index = undefined;
4050 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProtoOne(&params, fn_proto)) catch |err| switch (err) {
4051 error.OutOfMemory => return error.OutOfMemory,
4052 error.AnalysisFail => {},
4053 };
4054 continue;
4055 },
4056 .fn_proto => {
4057 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProto(fn_proto)) catch |err| switch (err) {
4058 error.OutOfMemory => return error.OutOfMemory,
4059 error.AnalysisFail => {},
4060 };
4061 continue;
4062 },
4063 else => unreachable,
4064 }
4065 },
4066 .fn_proto_simple => {
4067 var params: [1]Ast.Node.Index = undefined;
4068 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProtoSimple(&params, member_node)) catch |err| switch (err) {
4069 error.OutOfMemory => return error.OutOfMemory,
4070 error.AnalysisFail => {},
4071 };
4072 continue;
4073 },
4074 .fn_proto_multi => {
4075 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProtoMulti(member_node)) catch |err| switch (err) {
4076 error.OutOfMemory => return error.OutOfMemory,
4077 error.AnalysisFail => {},
4078 };
4079 continue;
4080 },
4081 .fn_proto_one => {
4082 var params: [1]Ast.Node.Index = undefined;
4083 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProtoOne(&params, member_node)) catch |err| switch (err) {
4084 error.OutOfMemory => return error.OutOfMemory,
4085 error.AnalysisFail => {},
4086 };
4087 continue;
4088 },
4089 .fn_proto => {
4090 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProto(member_node)) catch |err| switch (err) {
4091 error.OutOfMemory => return error.OutOfMemory,
4092 error.AnalysisFail => {},
4093 };
4094 continue;
4095 },
4096
4097 .global_var_decl => {
4098 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.globalVarDecl(member_node)) catch |err| switch (err) {
4099 error.OutOfMemory => return error.OutOfMemory,
4100 error.AnalysisFail => {},
4101 };
4102 continue;
4103 },
4104 .local_var_decl => {
4105 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.localVarDecl(member_node)) catch |err| switch (err) {
4106 error.OutOfMemory => return error.OutOfMemory,
4107 error.AnalysisFail => {},
4108 };
4109 continue;
4110 },
4111 .simple_var_decl => {
4112 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.simpleVarDecl(member_node)) catch |err| switch (err) {
4113 error.OutOfMemory => return error.OutOfMemory,
4114 error.AnalysisFail => {},
4115 };
4116 continue;
4117 },
4118 .aligned_var_decl => {
4119 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.alignedVarDecl(member_node)) catch |err| switch (err) {
4120 error.OutOfMemory => return error.OutOfMemory,
4121 error.AnalysisFail => {},
4122 };
4123 continue;
4124 },
4125
4126 .@"comptime" => {
4127 astgen.comptimeDecl(gz, &namespace.base, &wip_members, member_node) catch |err| switch (err) {
4128 error.OutOfMemory => return error.OutOfMemory,
4129 error.AnalysisFail => {},
4130 };
4131 continue;
4132 },
4133 .@"usingnamespace" => {
4134 astgen.usingnamespaceDecl(gz, &namespace.base, &wip_members, member_node) catch |err| switch (err) {
4135 error.OutOfMemory => return error.OutOfMemory,
4136 error.AnalysisFail => {},
4137 };
4138 continue;
4139 },
4140 .test_decl => {
4141 astgen.testDecl(gz, &namespace.base, &wip_members, member_node) catch |err| switch (err) {
4142 error.OutOfMemory => return error.OutOfMemory,
4143 error.AnalysisFail => {},
4144 };
4145 continue;
4146 },
4147 else => unreachable,
3900 const member = switch (try containerMember(gz, &namespace.base, &wip_members, member_node)) {
3901 .decl => continue,
3902 .field => |field| field,
41483903 };
41493904 if (member.comptime_token) |comptime_token| {
41503905 return astgen.failTok(comptime_token, "union fields cannot be marked comptime", .{});
......@@ -4205,7 +3960,6 @@ fn unionDeclInner(
42053960 wip_members.appendToField(@enumToInt(tag_value));
42063961 }
42073962 }
4208 assert(wip_members.decl_index == decl_count and wip_members.field_index == field_count);
42093963 if (field_count == 0) {
42103964 return astgen.failNode(node, "union declarations must have at least one tag", .{});
42113965 }
......@@ -4247,7 +4001,6 @@ fn containerDecl(
42474001 const tree = astgen.tree;
42484002 const token_tags = tree.tokens.items(.tag);
42494003 const node_tags = tree.nodes.items(.tag);
4250 const node_datas = tree.nodes.items(.data);
42514004
42524005 const prev_fn_block = astgen.fn_block;
42534006 astgen.fn_block = null;
......@@ -4419,130 +4172,9 @@ fn containerDecl(
44194172 for (container_decl.ast.members) |member_node| {
44204173 if (member_node == counts.nonexhaustive_node)
44214174 continue;
4422 const member = switch (node_tags[member_node]) {
4423 .container_field_init => tree.containerFieldInit(member_node),
4424 .container_field_align => tree.containerFieldAlign(member_node),
4425 .container_field => tree.containerField(member_node),
4426
4427 .fn_decl => {
4428 const fn_proto = node_datas[member_node].lhs;
4429 const body = node_datas[member_node].rhs;
4430 switch (node_tags[fn_proto]) {
4431 .fn_proto_simple => {
4432 var params: [1]Ast.Node.Index = undefined;
4433 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProtoSimple(&params, fn_proto)) catch |err| switch (err) {
4434 error.OutOfMemory => return error.OutOfMemory,
4435 error.AnalysisFail => {},
4436 };
4437 continue;
4438 },
4439 .fn_proto_multi => {
4440 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProtoMulti(fn_proto)) catch |err| switch (err) {
4441 error.OutOfMemory => return error.OutOfMemory,
4442 error.AnalysisFail => {},
4443 };
4444 continue;
4445 },
4446 .fn_proto_one => {
4447 var params: [1]Ast.Node.Index = undefined;
4448 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProtoOne(&params, fn_proto)) catch |err| switch (err) {
4449 error.OutOfMemory => return error.OutOfMemory,
4450 error.AnalysisFail => {},
4451 };
4452 continue;
4453 },
4454 .fn_proto => {
4455 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProto(fn_proto)) catch |err| switch (err) {
4456 error.OutOfMemory => return error.OutOfMemory,
4457 error.AnalysisFail => {},
4458 };
4459 continue;
4460 },
4461 else => unreachable,
4462 }
4463 },
4464 .fn_proto_simple => {
4465 var params: [1]Ast.Node.Index = undefined;
4466 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProtoSimple(&params, member_node)) catch |err| switch (err) {
4467 error.OutOfMemory => return error.OutOfMemory,
4468 error.AnalysisFail => {},
4469 };
4470 continue;
4471 },
4472 .fn_proto_multi => {
4473 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProtoMulti(member_node)) catch |err| switch (err) {
4474 error.OutOfMemory => return error.OutOfMemory,
4475 error.AnalysisFail => {},
4476 };
4477 continue;
4478 },
4479 .fn_proto_one => {
4480 var params: [1]Ast.Node.Index = undefined;
4481 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProtoOne(&params, member_node)) catch |err| switch (err) {
4482 error.OutOfMemory => return error.OutOfMemory,
4483 error.AnalysisFail => {},
4484 };
4485 continue;
4486 },
4487 .fn_proto => {
4488 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProto(member_node)) catch |err| switch (err) {
4489 error.OutOfMemory => return error.OutOfMemory,
4490 error.AnalysisFail => {},
4491 };
4492 continue;
4493 },
4494
4495 .global_var_decl => {
4496 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.globalVarDecl(member_node)) catch |err| switch (err) {
4497 error.OutOfMemory => return error.OutOfMemory,
4498 error.AnalysisFail => {},
4499 };
4500 continue;
4501 },
4502 .local_var_decl => {
4503 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.localVarDecl(member_node)) catch |err| switch (err) {
4504 error.OutOfMemory => return error.OutOfMemory,
4505 error.AnalysisFail => {},
4506 };
4507 continue;
4508 },
4509 .simple_var_decl => {
4510 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.simpleVarDecl(member_node)) catch |err| switch (err) {
4511 error.OutOfMemory => return error.OutOfMemory,
4512 error.AnalysisFail => {},
4513 };
4514 continue;
4515 },
4516 .aligned_var_decl => {
4517 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.alignedVarDecl(member_node)) catch |err| switch (err) {
4518 error.OutOfMemory => return error.OutOfMemory,
4519 error.AnalysisFail => {},
4520 };
4521 continue;
4522 },
4523
4524 .@"comptime" => {
4525 astgen.comptimeDecl(gz, &namespace.base, &wip_members, member_node) catch |err| switch (err) {
4526 error.OutOfMemory => return error.OutOfMemory,
4527 error.AnalysisFail => {},
4528 };
4529 continue;
4530 },
4531 .@"usingnamespace" => {
4532 astgen.usingnamespaceDecl(gz, &namespace.base, &wip_members, member_node) catch |err| switch (err) {
4533 error.OutOfMemory => return error.OutOfMemory,
4534 error.AnalysisFail => {},
4535 };
4536 continue;
4537 },
4538 .test_decl => {
4539 astgen.testDecl(gz, &namespace.base, &wip_members, member_node) catch |err| switch (err) {
4540 error.OutOfMemory => return error.OutOfMemory,
4541 error.AnalysisFail => {},
4542 };
4543 continue;
4544 },
4545 else => unreachable,
4175 const member = switch (try containerMember(gz, &namespace.base, &wip_members, member_node)) {
4176 .decl => continue,
4177 .field => |field| field,
45464178 };
45474179 assert(member.comptime_token == null);
45484180 assert(member.ast.type_expr == 0);
......@@ -4573,7 +4205,6 @@ fn containerDecl(
45734205 wip_members.appendToField(@enumToInt(tag_value_inst));
45744206 }
45754207 }
4576 assert(wip_members.decl_index == counts.decls and wip_members.field_index == counts.total_fields);
45774208
45784209 if (block_scope.instructions.items.len != 0) {
45794210 _ = try block_scope.addBreak(.break_inline, decl_inst, .void_value);
......@@ -4617,131 +4248,8 @@ fn containerDecl(
46174248 defer wip_members.deinit(gpa);
46184249
46194250 for (container_decl.ast.members) |member_node| {
4620 switch (node_tags[member_node]) {
4621 .container_field_init, .container_field_align, .container_field => {},
4622
4623 .fn_decl => {
4624 const fn_proto = node_datas[member_node].lhs;
4625 const body = node_datas[member_node].rhs;
4626 switch (node_tags[fn_proto]) {
4627 .fn_proto_simple => {
4628 var params: [1]Ast.Node.Index = undefined;
4629 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProtoSimple(&params, fn_proto)) catch |err| switch (err) {
4630 error.OutOfMemory => return error.OutOfMemory,
4631 error.AnalysisFail => {},
4632 };
4633 continue;
4634 },
4635 .fn_proto_multi => {
4636 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProtoMulti(fn_proto)) catch |err| switch (err) {
4637 error.OutOfMemory => return error.OutOfMemory,
4638 error.AnalysisFail => {},
4639 };
4640 continue;
4641 },
4642 .fn_proto_one => {
4643 var params: [1]Ast.Node.Index = undefined;
4644 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProtoOne(&params, fn_proto)) catch |err| switch (err) {
4645 error.OutOfMemory => return error.OutOfMemory,
4646 error.AnalysisFail => {},
4647 };
4648 continue;
4649 },
4650 .fn_proto => {
4651 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, body, tree.fnProto(fn_proto)) catch |err| switch (err) {
4652 error.OutOfMemory => return error.OutOfMemory,
4653 error.AnalysisFail => {},
4654 };
4655 continue;
4656 },
4657 else => unreachable,
4658 }
4659 },
4660 .fn_proto_simple => {
4661 var params: [1]Ast.Node.Index = undefined;
4662 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProtoSimple(&params, member_node)) catch |err| switch (err) {
4663 error.OutOfMemory => return error.OutOfMemory,
4664 error.AnalysisFail => {},
4665 };
4666 continue;
4667 },
4668 .fn_proto_multi => {
4669 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProtoMulti(member_node)) catch |err| switch (err) {
4670 error.OutOfMemory => return error.OutOfMemory,
4671 error.AnalysisFail => {},
4672 };
4673 continue;
4674 },
4675 .fn_proto_one => {
4676 var params: [1]Ast.Node.Index = undefined;
4677 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProtoOne(&params, member_node)) catch |err| switch (err) {
4678 error.OutOfMemory => return error.OutOfMemory,
4679 error.AnalysisFail => {},
4680 };
4681 continue;
4682 },
4683 .fn_proto => {
4684 astgen.fnDecl(gz, &namespace.base, &wip_members, member_node, 0, tree.fnProto(member_node)) catch |err| switch (err) {
4685 error.OutOfMemory => return error.OutOfMemory,
4686 error.AnalysisFail => {},
4687 };
4688 continue;
4689 },
4690
4691 .global_var_decl => {
4692 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.globalVarDecl(member_node)) catch |err| switch (err) {
4693 error.OutOfMemory => return error.OutOfMemory,
4694 error.AnalysisFail => {},
4695 };
4696 continue;
4697 },
4698 .local_var_decl => {
4699 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.localVarDecl(member_node)) catch |err| switch (err) {
4700 error.OutOfMemory => return error.OutOfMemory,
4701 error.AnalysisFail => {},
4702 };
4703 continue;
4704 },
4705 .simple_var_decl => {
4706 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.simpleVarDecl(member_node)) catch |err| switch (err) {
4707 error.OutOfMemory => return error.OutOfMemory,
4708 error.AnalysisFail => {},
4709 };
4710 continue;
4711 },
4712 .aligned_var_decl => {
4713 astgen.globalVarDecl(gz, &namespace.base, &wip_members, member_node, tree.alignedVarDecl(member_node)) catch |err| switch (err) {
4714 error.OutOfMemory => return error.OutOfMemory,
4715 error.AnalysisFail => {},
4716 };
4717 continue;
4718 },
4719
4720 .@"comptime" => {
4721 astgen.comptimeDecl(gz, &namespace.base, &wip_members, member_node) catch |err| switch (err) {
4722 error.OutOfMemory => return error.OutOfMemory,
4723 error.AnalysisFail => {},
4724 };
4725 continue;
4726 },
4727 .@"usingnamespace" => {
4728 astgen.usingnamespaceDecl(gz, &namespace.base, &wip_members, member_node) catch |err| switch (err) {
4729 error.OutOfMemory => return error.OutOfMemory,
4730 error.AnalysisFail => {},
4731 };
4732 continue;
4733 },
4734 .test_decl => {
4735 astgen.testDecl(gz, &namespace.base, &wip_members, member_node) catch |err| switch (err) {
4736 error.OutOfMemory => return error.OutOfMemory,
4737 error.AnalysisFail => {},
4738 };
4739 continue;
4740 },
4741 else => unreachable,
4742 }
4251 _ = try containerMember(gz, &namespace.base, &wip_members, member_node);
47434252 }
4744 assert(wip_members.decl_index == decl_count);
47454253
47464254 try gz.setOpaque(decl_inst, .{
47474255 .src_node = node,
......@@ -4759,6 +4267,131 @@ fn containerDecl(
47594267 }
47604268}
47614269
4270const ContainerMemberResult = union(enum) { decl, field: Ast.full.ContainerField };
4271
4272fn containerMember(
4273 gz: *GenZir,
4274 scope: *Scope,
4275 wip_members: *WipMembers,
4276 member_node: Ast.Node.Index,
4277) InnerError!ContainerMemberResult {
4278 const astgen = gz.astgen;
4279 const tree = astgen.tree;
4280 const node_tags = tree.nodes.items(.tag);
4281 const node_datas = tree.nodes.items(.data);
4282 switch (node_tags[member_node]) {
4283 .container_field_init => return ContainerMemberResult{ .field = tree.containerFieldInit(member_node) },
4284 .container_field_align => return ContainerMemberResult{ .field = tree.containerFieldAlign(member_node) },
4285 .container_field => return ContainerMemberResult{ .field = tree.containerField(member_node) },
4286
4287 .fn_decl => {
4288 const fn_proto = node_datas[member_node].lhs;
4289 const body = node_datas[member_node].rhs;
4290 switch (node_tags[fn_proto]) {
4291 .fn_proto_simple => {
4292 var params: [1]Ast.Node.Index = undefined;
4293 astgen.fnDecl(gz, scope, wip_members, member_node, body, tree.fnProtoSimple(&params, fn_proto)) catch |err| switch (err) {
4294 error.OutOfMemory => return error.OutOfMemory,
4295 error.AnalysisFail => {},
4296 };
4297 },
4298 .fn_proto_multi => {
4299 astgen.fnDecl(gz, scope, wip_members, member_node, body, tree.fnProtoMulti(fn_proto)) catch |err| switch (err) {
4300 error.OutOfMemory => return error.OutOfMemory,
4301 error.AnalysisFail => {},
4302 };
4303 },
4304 .fn_proto_one => {
4305 var params: [1]Ast.Node.Index = undefined;
4306 astgen.fnDecl(gz, scope, wip_members, member_node, body, tree.fnProtoOne(&params, fn_proto)) catch |err| switch (err) {
4307 error.OutOfMemory => return error.OutOfMemory,
4308 error.AnalysisFail => {},
4309 };
4310 },
4311 .fn_proto => {
4312 astgen.fnDecl(gz, scope, wip_members, member_node, body, tree.fnProto(fn_proto)) catch |err| switch (err) {
4313 error.OutOfMemory => return error.OutOfMemory,
4314 error.AnalysisFail => {},
4315 };
4316 },
4317 else => unreachable,
4318 }
4319 },
4320 .fn_proto_simple => {
4321 var params: [1]Ast.Node.Index = undefined;
4322 astgen.fnDecl(gz, scope, wip_members, member_node, 0, tree.fnProtoSimple(&params, member_node)) catch |err| switch (err) {
4323 error.OutOfMemory => return error.OutOfMemory,
4324 error.AnalysisFail => {},
4325 };
4326 },
4327 .fn_proto_multi => {
4328 astgen.fnDecl(gz, scope, wip_members, member_node, 0, tree.fnProtoMulti(member_node)) catch |err| switch (err) {
4329 error.OutOfMemory => return error.OutOfMemory,
4330 error.AnalysisFail => {},
4331 };
4332 },
4333 .fn_proto_one => {
4334 var params: [1]Ast.Node.Index = undefined;
4335 astgen.fnDecl(gz, scope, wip_members, member_node, 0, tree.fnProtoOne(&params, member_node)) catch |err| switch (err) {
4336 error.OutOfMemory => return error.OutOfMemory,
4337 error.AnalysisFail => {},
4338 };
4339 },
4340 .fn_proto => {
4341 astgen.fnDecl(gz, scope, wip_members, member_node, 0, tree.fnProto(member_node)) catch |err| switch (err) {
4342 error.OutOfMemory => return error.OutOfMemory,
4343 error.AnalysisFail => {},
4344 };
4345 },
4346
4347 .global_var_decl => {
4348 astgen.globalVarDecl(gz, scope, wip_members, member_node, tree.globalVarDecl(member_node)) catch |err| switch (err) {
4349 error.OutOfMemory => return error.OutOfMemory,
4350 error.AnalysisFail => {},
4351 };
4352 },
4353 .local_var_decl => {
4354 astgen.globalVarDecl(gz, scope, wip_members, member_node, tree.localVarDecl(member_node)) catch |err| switch (err) {
4355 error.OutOfMemory => return error.OutOfMemory,
4356 error.AnalysisFail => {},
4357 };
4358 },
4359 .simple_var_decl => {
4360 astgen.globalVarDecl(gz, scope, wip_members, member_node, tree.simpleVarDecl(member_node)) catch |err| switch (err) {
4361 error.OutOfMemory => return error.OutOfMemory,
4362 error.AnalysisFail => {},
4363 };
4364 },
4365 .aligned_var_decl => {
4366 astgen.globalVarDecl(gz, scope, wip_members, member_node, tree.alignedVarDecl(member_node)) catch |err| switch (err) {
4367 error.OutOfMemory => return error.OutOfMemory,
4368 error.AnalysisFail => {},
4369 };
4370 },
4371
4372 .@"comptime" => {
4373 astgen.comptimeDecl(gz, scope, wip_members, member_node) catch |err| switch (err) {
4374 error.OutOfMemory => return error.OutOfMemory,
4375 error.AnalysisFail => {},
4376 };
4377 },
4378 .@"usingnamespace" => {
4379 astgen.usingnamespaceDecl(gz, scope, wip_members, member_node) catch |err| switch (err) {
4380 error.OutOfMemory => return error.OutOfMemory,
4381 error.AnalysisFail => {},
4382 };
4383 },
4384 .test_decl => {
4385 astgen.testDecl(gz, scope, wip_members, member_node) catch |err| switch (err) {
4386 error.OutOfMemory => return error.OutOfMemory,
4387 error.AnalysisFail => {},
4388 };
4389 },
4390 else => unreachable,
4391 }
4392 return .decl;
4393}
4394
47624395fn errorSetDecl(gz: *GenZir, rl: ResultLoc, node: Ast.Node.Index) InnerError!Zir.Inst.Ref {
47634396 const astgen = gz.astgen;
47644397 const gpa = astgen.gpa;