tiny.choir.SymbolTable

1pub const SymbolTable = struct {2    allocator: std.mem.Allocator,3    symbols: std.StringHashMapUnmanaged(*Operation),45    pub const symbol_attr_names = struct {6        pub const sym_name = "sym_name";7        pub const sym_visibility = "sym_visibility";8    };910    pub const Visibility = enum {11        public,12        private,13        nested,1415        pub fn fromString(value: []const u8) ?Visibility {16            if (std.mem.eql(u8, value, "public")) return .public;17            if (std.mem.eql(u8, value, "private")) return .private;18            if (std.mem.eql(u8, value, "nested")) return .nested;19            return null;20        }2122        pub fn toString(self: Visibility) []const u8 {23            return @tagName(self);24        }25    };2627    pub const Collection = struct {28        allocator: std.mem.Allocator,29        tables: std.AutoArrayHashMapUnmanaged(*Operation, SymbolTable) = .empty,3031        pub fn init(allocator: std.mem.Allocator) Collection {32            return .{ .allocator = allocator };33        }3435        pub fn deinit(self: *Collection) void {36            for (self.tables.values()) |*table| {37                table.deinit();38            }39            self.tables.deinit(self.allocator);40            self.tables = .empty;41        }4243        pub fn getSymbolTable(self: *Collection, op: *Operation) SymbolTableError!*SymbolTable {44            if (!isSymbolTableOperation(op)) return error.InvalidSymbolTable;4546            const entry = try self.tables.getOrPut(self.allocator, op);47            if (!entry.found_existing) {48                entry.value_ptr.* = SymbolTable.init(self.allocator);49                entry.value_ptr.buildFromOperation(op) catch |err| {50                    entry.value_ptr.deinit();51                    _ = self.tables.swapRemove(op);52                    return err;53                };54            }55            return entry.value_ptr;56        }5758        pub fn invalidateSymbolTable(self: *Collection, op: *Operation) void {59            if (self.tables.getPtr(op)) |table| {60                table.deinit();61                _ = self.tables.swapRemove(op);62            }63        }6465        pub fn lookupSymbolIn(66            self: *Collection,67            op: *Operation,68            name: []const u8,69        ) SymbolTableError!?*Operation {70            if (!isSymbolTableOperation(op)) return null;71            const table = try self.getSymbolTable(op);72            return table.lookup(name);73        }7475        pub fn lookupSymbolRefIn(76            self: *Collection,77            op: *Operation,78            symbol_ref: *const Attribute.SymbolRefAttr,79        ) SymbolTableError!?*Operation {80            var resolved = try self.lookupSymbolIn(op, symbol_ref.getRootReference()) orelse return null;81            for (symbol_ref.getNestedReferences()) |nested_ref| {82                resolved = try self.lookupSymbolIn(resolved, nested_ref) orelse return null;83                if (getSymbolVisibility(resolved) == .private) return null;84            }85            return resolved;86        }8788        pub fn lookupNearestSymbolFrom(89            self: *Collection,90            from: *Operation,91            name: []const u8,92        ) SymbolTableError!?*Operation {93            const table_op = getNearestSymbolTable(from) orelse return null;94            return self.lookupSymbolIn(table_op, name);95        }9697        pub fn lookupNearestSymbolRefFrom(98            self: *Collection,99            from: *Operation,100            symbol_ref: *const Attribute.SymbolRefAttr,101        ) SymbolTableError!?*Operation {102            const table_op = getNearestSymbolTable(from) orelse return null;103            return self.lookupSymbolRefIn(table_op, symbol_ref);104        }105    };106107    pub fn init(allocator: std.mem.Allocator) SymbolTable {108        return .{109            .allocator = allocator,110            .symbols = .{},111        };112    }113114    pub fn deinit(self: *SymbolTable) void {115        self.symbols.deinit(self.allocator);116    }117118    pub fn clearRetainingCapacity(self: *SymbolTable) void {119        self.symbols.clearRetainingCapacity();120    }121122    pub fn lookup(self: *const SymbolTable, name: []const u8) ?*Operation {123        return self.symbols.get(name);124    }125126    pub fn iterator(self: *SymbolTable) std.StringHashMapUnmanaged(*Operation).Iterator {127        return self.symbols.iterator();128    }129130    pub fn buildFromOperation(self: *SymbolTable, op: *Operation) SymbolTableError!void {131        self.clearRetainingCapacity();132        if (!isSymbolTableOperation(op)) return error.InvalidSymbolTable;133        if (op.regions.items.len != 1) return error.InvalidSymbolTable;134        const region = &op.regions.items[0];135        if (region.blocks.size != 1) return error.InvalidSymbolTable;136        try self.appendFromRegion(region);137    }138139    fn appendFromRegion(self: *SymbolTable, region: *Region) SymbolTableError!void {140        const block = region.blocks.front() orelse return;141        var ops = block.getOperations();142        while (ops.next()) |op| {143            if (getSymbolName(op)) |name| {144                try self.addSymbol(name, op);145            }146        }147    }148149    fn addSymbol(self: *SymbolTable, name: []const u8, op: *Operation) SymbolTableError!void {150        const entry = try self.symbols.getOrPut(self.allocator, name);151        if (entry.found_existing) return error.DuplicateSymbol;152        entry.value_ptr.* = op;153    }154155    pub fn isSymbolTableOperation(op: *Operation) bool {156        return op.getTraits().is_symbol_table;157    }158159    pub fn isSymbolOperation(op: *Operation) bool {160        return op.interface(interfaces.SymbolOpInterface) != null;161    }162163    pub fn verifyOperation(op: *Operation) anyerror!void {164        var symbol_tables = Collection.init(op.allocator);165        defer symbol_tables.deinit();166        _ = try symbol_tables.getSymbolTable(op);167        try verifySymbols(op);168        try verifySymbolUsesInSymbolTable(&symbol_tables, op);169    }170171    fn verifySymbols(op: *Operation) SymbolTableError!void {172        if (!isSymbolTableOperation(op)) return error.InvalidSymbolTable;173        if (op.regions.items.len != 1) return error.InvalidSymbolTable;174        const region = &op.regions.items[0];175        if (region.blocks.size != 1) return error.InvalidSymbolTable;176        const block = region.blocks.front() orelse return;177        var ops = block.getOperations();178        while (ops.next()) |candidate| {179            if (!isSymbolOperation(candidate)) continue;180            if (isDeclaration(candidate) and getSymbolVisibility(candidate) == .public) {181                return error.InvalidSymbolDeclaration;182            }183        }184    }185186    pub fn lookupSymbolIn(op: *Operation, name: []const u8) ?*Operation {187        if (!isSymbolTableOperation(op)) return null;188        if (op.regions.items.len == 0) return null;189        const region = &op.regions.items[0];190        const block = region.blocks.front() orelse return null;191        var ops = block.getOperations();192        while (ops.next()) |candidate| {193            if (getSymbolName(candidate)) |symbol_name| {194                if (std.mem.eql(u8, symbol_name, name)) return candidate;195            }196        }197        return null;198    }199200    pub fn lookupSymbolRefIn(op: *Operation, symbol_ref: *const Attribute.SymbolRefAttr) ?*Operation {201        var resolved = lookupSymbolIn(op, symbol_ref.getRootReference()) orelse return null;202        for (symbol_ref.getNestedReferences()) |nested_ref| {203            resolved = lookupSymbolIn(resolved, nested_ref) orelse return null;204            if (getSymbolVisibility(resolved) == .private) return null;205        }206        return resolved;207    }208209    pub fn getNearestSymbolTable(from: *Operation) ?*Operation {210        var current: ?*Operation = from;211        while (current) |op| {212            if (isSymbolTableOperation(op)) return op;213            current = op.getParentOp();214        }215        return null;216    }217218    pub fn lookupNearestSymbolFrom(from: *Operation, name: []const u8) ?*Operation {219        const table_op = getNearestSymbolTable(from) orelse return null;220        return lookupSymbolIn(table_op, name);221    }222223    pub fn lookupNearestSymbolRefFrom(from: *Operation, symbol_ref: *const Attribute.SymbolRefAttr) ?*Operation {224        const table_op = getNearestSymbolTable(from) orelse return null;225        return lookupSymbolRefIn(table_op, symbol_ref);226    }227228    pub fn collectSymbolUses(229        allocator: std.mem.Allocator,230        from: *Operation,231    ) anyerror!SymbolUseRange {232        var range = SymbolUseRange{};233        errdefer range.deinit(allocator);234        try appendSymbolUsesFromOperation(allocator, &range, from, null);235        return range;236    }237238    pub fn collectSymbolUsesInRegion(239        allocator: std.mem.Allocator,240        from: *Region,241    ) anyerror!SymbolUseRange {242        var range = SymbolUseRange{};243        errdefer range.deinit(allocator);244        try appendSymbolUsesFromRegion(allocator, &range, from, null);245        return range;246    }247248    pub fn collectSymbolUsesInSymbolTable(249        allocator: std.mem.Allocator,250        op: *Operation,251    ) anyerror!SymbolUseRange {252        if (!isSymbolTableOperation(op)) return error.InvalidSymbolTable;253        var range = SymbolUseRange{};254        errdefer range.deinit(allocator);255        for (op.regions.items) |*region| {256            try appendSymbolUsesFromRegion(allocator, &range, region, null);257        }258        return range;259    }260261    pub fn collectSymbolUsesOf(262        allocator: std.mem.Allocator,263        from: *Operation,264        symbol_ref: *const Attribute.SymbolRefAttr,265    ) anyerror!SymbolUseRange {266        var range = SymbolUseRange{};267        errdefer range.deinit(allocator);268        try appendSymbolUsesFromOperation(allocator, &range, from, symbol_ref);269        return range;270    }271272    pub fn collectSymbolUsesOfInRegion(273        allocator: std.mem.Allocator,274        from: *Region,275        symbol_ref: *const Attribute.SymbolRefAttr,276    ) anyerror!SymbolUseRange {277        var range = SymbolUseRange{};278        errdefer range.deinit(allocator);279        try appendSymbolUsesFromRegion(allocator, &range, from, symbol_ref);280        return range;281    }282283    pub fn collectSymbolUsesOfInSymbolTable(284        allocator: std.mem.Allocator,285        op: *Operation,286        symbol_ref: *const Attribute.SymbolRefAttr,287    ) anyerror!SymbolUseRange {288        if (!isSymbolTableOperation(op)) return error.InvalidSymbolTable;289        var range = SymbolUseRange{};290        errdefer range.deinit(allocator);291        for (op.regions.items) |*region| {292            try appendSymbolUsesFromRegion(allocator, &range, region, symbol_ref);293        }294        return range;295    }296297    pub fn symbolKnownUseEmpty(298        allocator: std.mem.Allocator,299        from: *Operation,300        symbol_ref: *const Attribute.SymbolRefAttr,301    ) anyerror!bool {302        var uses = try collectSymbolUsesOf(allocator, from, symbol_ref);303        defer uses.deinit(allocator);304        return uses.empty();305    }306307    pub fn symbolKnownUseEmptyInRegion(308        allocator: std.mem.Allocator,309        from: *Region,310        symbol_ref: *const Attribute.SymbolRefAttr,311    ) anyerror!bool {312        var uses = try collectSymbolUsesOfInRegion(allocator, from, symbol_ref);313        defer uses.deinit(allocator);314        return uses.empty();315    }316317    pub fn symbolKnownUseEmptyInSymbolTable(318        allocator: std.mem.Allocator,319        op: *Operation,320        symbol_ref: *const Attribute.SymbolRefAttr,321    ) anyerror!bool {322        var uses = try collectSymbolUsesOfInSymbolTable(allocator, op, symbol_ref);323        defer uses.deinit(allocator);324        return uses.empty();325    }326327    pub fn replaceAllSymbolUsesInRegion(328        allocator: std.mem.Allocator,329        from: *Region,330        old_ref: *const Attribute.SymbolRefAttr,331        new_leaf: []const u8,332    ) anyerror!usize {333        return replaceSymbolUsesInRegion(allocator, from, old_ref, new_leaf);334    }335336    pub fn replaceAllSymbolUsesInSymbolTable(337        allocator: std.mem.Allocator,338        op: *Operation,339        old_ref: *const Attribute.SymbolRefAttr,340        new_leaf: []const u8,341    ) anyerror!usize {342        if (!isSymbolTableOperation(op)) return error.InvalidSymbolTable;343        var replaced: usize = 0;344        for (op.regions.items) |*region| {345            replaced += try replaceSymbolUsesInRegion(allocator, region, old_ref, new_leaf);346        }347        return replaced;348    }349350    pub fn renameSymbolInSymbolTable(351        allocator: std.mem.Allocator,352        op: *Operation,353        symbol: *Operation,354        new_name: []const u8,355    ) anyerror!usize {356        if (!isSymbolTableOperation(op)) return error.InvalidSymbolTable;357        if (symbol.getParentOp() != op) return error.InvalidSymbolTable;358        const old_name = getSymbolName(symbol) orelse return error.InvalidSymbol;359        if (std.mem.eql(u8, old_name, new_name)) return 0;360        if (lookupSymbolIn(op, new_name)) |existing| {361            if (existing != symbol) return error.DuplicateSymbol;362        }363364        var symbol_tables = Collection.init(allocator);365        defer symbol_tables.deinit();366        var users = try SymbolUserMap.init(allocator, &symbol_tables, op);367        defer users.deinit();368        const replaced = try users.replaceAllUsesWith(symbol, new_name);369        try setSymbolName(symbol, new_name);370        symbol_tables.invalidateSymbolTable(op);371        return replaced;372    }373374    pub fn getSymbolName(op: *Operation) ?[]const u8 {375        const iface = op.interface(interfaces.SymbolOpInterface) orelse return null;376        return iface.call(.getSymbolName, .{});377    }378379    pub fn setSymbolName(op: *Operation, name: []const u8) anyerror!void {380        const iface = op.interface(interfaces.SymbolOpInterface) orelse return error.InvalidSymbol;381        try iface.call(.setSymbolName, .{name});382    }383384    pub fn isDeclaration(op: *Operation) bool {385        const iface = op.interface(interfaces.SymbolOpInterface) orelse return false;386        return iface.call(.isDeclaration, .{});387    }388389    pub fn getSymbolVisibility(op: *const Operation) Visibility {390        const string_attr = op.getAttrAs(Attribute.StringAttr, symbol_attr_names.sym_visibility) orelse return .public;391        return Visibility.fromString(string_attr.getValue()) orelse .public;392    }393394    pub fn setSymbolVisibility(op: *Operation, visibility: Visibility) anyerror!void {395        if (!isSymbolOperation(op)) return error.InvalidSymbol;396        if (visibility == .public) {397            if (isDeclaration(op)) return error.InvalidSymbolDeclaration;398            _ = op.removeAttr(symbol_attr_names.sym_visibility);399            return;400        }401        try op.setAttr(402            symbol_attr_names.sym_visibility,403            try op.getContext().getStringAttr(visibility.toString()),404        );405    }406407    fn appendSymbolRefsFromOperation(408        allocator: std.mem.Allocator,409        range: *SymbolUseRange,410        op: *Operation,411        target_ref: ?*const Attribute.SymbolRefAttr,412    ) anyerror!void {413        var attrs = op.getAttrs();414        while (attrs.next()) |attr| {415            try appendSymbolRefsFromAttribute(allocator, range, op, attr.name, attr.value, target_ref);416        }417    }418419    fn appendSymbolRefsFromAttribute(420        allocator: std.mem.Allocator,421        range: *SymbolUseRange,422        op: *Operation,423        attr_name: []const u8,424        attr: Attribute,425        target_ref: ?*const Attribute.SymbolRefAttr,426    ) anyerror!void {427        if (getSymbolRefAttr(attr)) |symbol_ref| {428            if (target_ref) |target| {429                if (!isReferencePrefixOf(target, symbol_ref)) return;430            }431            try range.append(allocator, .{432                .user = op,433                .attr_name = attr_name,434                .symbol_ref = symbol_ref,435            });436            return;437        }438439        const array_attr = getArrayAttr(attr) orelse return;440        for (array_attr.values) |child| {441            try appendSymbolRefsFromAttribute(allocator, range, op, attr_name, child, target_ref);442        }443    }444445    fn appendSymbolUsesFromOperation(446        allocator: std.mem.Allocator,447        range: *SymbolUseRange,448        op: *Operation,449        target_ref: ?*const Attribute.SymbolRefAttr,450    ) anyerror!void {451        var state = SymbolUseWalkState{452            .allocator = allocator,453            .range = range,454            .target_ref = target_ref,455        };456        _ = try op.walk(.{ .order = .pre_order }, &state, SymbolUseWalkState.visit);457    }458459    fn verifySymbolUsesInSymbolTable(symbol_tables: *Collection, op: *Operation) anyerror!void {460        if (!isSymbolTableOperation(op)) return error.InvalidSymbolTable;461        for (op.regions.items) |*region| {462            try verifySymbolUsesInRegion(symbol_tables, region);463        }464    }465466    fn verifySymbolUsesFromOperation(symbol_tables: *Collection, op: *Operation) anyerror!void {467        var state = VerifySymbolUsesWalkState{ .symbol_tables = symbol_tables };468        _ = try op.walk(.{ .order = .pre_order }, &state, VerifySymbolUsesWalkState.visit);469    }470471    fn verifySymbolUsesOnOperation(symbol_tables: *Collection, op: *Operation) anyerror!void {472        if (op.interface(interfaces.SymbolUserOpInterface)) |iface| {473            try iface.call(.verifySymbolUses, .{symbol_tables});474        }475        var attrs = op.getDiscardableAttrs();476        while (attrs.next()) |attr| {477            if (attr.value.interface(interfaces.SymbolUserAttrInterface)) |iface| {478                try iface.call(.verifySymbolUses, .{ op, symbol_tables });479            }480        }481    }482483    fn verifySymbolUsesInRegion(symbol_tables: *Collection, region: *Region) anyerror!void {484        var state = VerifySymbolUsesWalkState{ .symbol_tables = symbol_tables };485        _ = try region.walkOperations(.{ .order = .pre_order }, &state, VerifySymbolUsesWalkState.visit);486    }487488    fn appendSymbolUsesFromRegion(489        allocator: std.mem.Allocator,490        range: *SymbolUseRange,491        region: *Region,492        target_ref: ?*const Attribute.SymbolRefAttr,493    ) anyerror!void {494        var state = SymbolUseWalkState{495            .allocator = allocator,496            .range = range,497            .target_ref = target_ref,498        };499        _ = try region.walkOperations(.{ .order = .pre_order }, &state, SymbolUseWalkState.visit);500    }501502    fn replaceSymbolUsesOnOperation(503        allocator: std.mem.Allocator,504        op: *Operation,505        old_ref: *const Attribute.SymbolRefAttr,506        new_leaf: []const u8,507    ) anyerror!usize {508        var replaced: usize = 0;509        var inline_snapshot: [4]NamedAttribute = undefined;510        const attr_count = op.getNumAttrs();511        const attr_snapshot = if (attr_count <= inline_snapshot.len)512            inline_snapshot[0..attr_count]513        else514            try allocator.alloc(NamedAttribute, attr_count);515        defer if (attr_count > inline_snapshot.len) allocator.free(attr_snapshot);516        var attrs = op.getAttrs();517        var attr_index: usize = 0;518        while (attrs.next()) |attr| : (attr_index += 1) {519            if (attr_index >= attr_snapshot.len) return error.OperationAttributesChanged;520            attr_snapshot[attr_index] = attr;521        }522        if (attr_index != attr_snapshot.len) return error.OperationAttributesChanged;523        for (attr_snapshot) |attr| {524            const result = try replaceSymbolUsesInAttribute(allocator, op, old_ref, attr.value, new_leaf);525            const replacement = result.attr orelse continue;526            try op.setAttr(attr.name, replacement);527            replaced += result.replaced;528        }529        return replaced;530    }531532    fn replaceSymbolUsesInAttribute(533        allocator: std.mem.Allocator,534        op: *Operation,535        old_ref: *const Attribute.SymbolRefAttr,536        attr: Attribute,537        new_leaf: []const u8,538    ) anyerror!AttributeReplacement {539        if (getSymbolRefAttr(attr)) |symbol_ref| {540            const replacement = try replacementSymbolRefAttr(allocator, op, old_ref, symbol_ref, new_leaf) orelse return .{};541            return .{ .attr = replacement, .replaced = 1 };542        }543544        const array_attr = getArrayAttr(attr) orelse return .{};545        var changed = false;546        var replaced: usize = 0;547        const values = try allocator.alloc(Attribute, array_attr.values.len);548        defer allocator.free(values);549        for (array_attr.values, 0..) |child, index| {550            const result = try replaceSymbolUsesInAttribute(allocator, op, old_ref, child, new_leaf);551            values[index] = result.attr orelse child;552            if (result.attr != null) changed = true;553            replaced += result.replaced;554        }555        if (!changed) return .{};556        return .{557            .attr = try op.getContext().getArrayAttr(values),558            .replaced = replaced,559        };560    }561562    fn replaceSymbolUsesInOperation(563        allocator: std.mem.Allocator,564        op: *Operation,565        old_ref: *const Attribute.SymbolRefAttr,566        new_leaf: []const u8,567    ) anyerror!usize {568        var state = ReplaceSymbolUsesWalkState{569            .allocator = allocator,570            .old_ref = old_ref,571            .new_leaf = new_leaf,572        };573        _ = try op.walk(.{ .order = .pre_order }, &state, ReplaceSymbolUsesWalkState.visit);574        return state.replaced;575    }576577    fn replaceSymbolUsesInRegion(578        allocator: std.mem.Allocator,579        region: *Region,580        old_ref: *const Attribute.SymbolRefAttr,581        new_leaf: []const u8,582    ) anyerror!usize {583        var state = ReplaceSymbolUsesWalkState{584            .allocator = allocator,585            .old_ref = old_ref,586            .new_leaf = new_leaf,587        };588        _ = try region.walkOperations(.{ .order = .pre_order }, &state, ReplaceSymbolUsesWalkState.visit);589        return state.replaced;590    }591592    fn replacementSymbolRefAttr(593        allocator: std.mem.Allocator,594        op: *Operation,595        old_ref: *const Attribute.SymbolRefAttr,596        current_ref: *const Attribute.SymbolRefAttr,597        new_leaf: []const u8,598    ) anyerror!?Attribute {599        if (!isReferencePrefixOf(old_ref, current_ref)) return null;600        if (current_ref.getNestedReferences().len == 0) {601            return try op.getContext().getFlatSymbolRefAttr(new_leaf);602        }603        if (old_ref.getNestedReferences().len == 0) {604            return try op.getContext().getSymbolRefAttr(new_leaf, current_ref.getNestedReferences());605        }606607        const nested = try allocator.dupe([]const u8, current_ref.getNestedReferences());608        defer allocator.free(nested);609        nested[old_ref.getNestedReferences().len - 1] = new_leaf;610        return try op.getContext().getSymbolRefAttr(current_ref.getRootReference(), nested);611    }612613    fn symbolUsePrefix(use: SymbolUse, nested_len: usize) anyerror!SymbolUse {614        const attr = if (nested_len == 0)615            try use.user.getContext().getFlatSymbolRefAttr(use.symbol_ref.getRootReference())616        else617            try use.user.getContext().getSymbolRefAttr(618                use.symbol_ref.getRootReference(),619                use.symbol_ref.getNestedReferences()[0..nested_len],620            );621        const symbol_ref = attr.cast(Attribute.SymbolRefAttr).?;622        return .{623            .user = use.user,624            .attr_name = use.attr_name,625            .symbol_ref = symbol_ref,626        };627    }628629    fn sameUse(a: SymbolUse, b: SymbolUse) bool {630        return a.user == b.user and631            std.mem.eql(u8, a.attr_name, b.attr_name) and632            symbolRefsEqual(a.symbol_ref, b.symbol_ref);633    }634635    fn symbolRefsEqual(a: *const Attribute.SymbolRefAttr, b: *const Attribute.SymbolRefAttr) bool {636        if (a == b) return true;637        if (!std.mem.eql(u8, a.getRootReference(), b.getRootReference())) return false;638        const a_nested = a.getNestedReferences();639        const b_nested = b.getNestedReferences();640        if (a_nested.len != b_nested.len) return false;641        for (a_nested, b_nested) |a_ref, b_ref| {642            if (!std.mem.eql(u8, a_ref, b_ref)) return false;643        }644        return true;645    }646647    fn isReferencePrefixOf(prefix: *const Attribute.SymbolRefAttr, symbol_ref: *const Attribute.SymbolRefAttr) bool {648        if (!std.mem.eql(u8, prefix.getRootReference(), symbol_ref.getRootReference())) return false;649        const prefix_nested = prefix.getNestedReferences();650        const ref_nested = symbol_ref.getNestedReferences();651        if (prefix_nested.len > ref_nested.len) return false;652        for (prefix_nested, 0..) |nested, index| {653            if (!std.mem.eql(u8, nested, ref_nested[index])) return false;654        }655        return true;656    }657658    fn getSymbolRefAttr(attr: Attribute) ?*const Attribute.SymbolRefAttr {659        if (!std.mem.eql(u8, attr.abstract.name, attribute.builtin_attr_names.symbol_ref)) return null;660        return attr.cast(Attribute.SymbolRefAttr);661    }662663    fn getArrayAttr(attr: Attribute) ?*const Attribute.ArrayAttr {664        if (!std.mem.eql(u8, attr.abstract.name, attribute.builtin_attr_names.array)) return null;665        return attr.cast(Attribute.ArrayAttr);666    }667};

1pub const SymbolTable = ir.SymbolTable;