radiance · commit

compiler: Own substituted nominal member tables

f77a58b2f97e7bef00fe9bd9d65d9bd4275d25e492029c4feeee92a23a1f592d

Alexis Sellier committed 6 days ago 1 parent c0a02bfa

lib/std/lang/resolver.rad +4 -4

        set map.arguments[i] = argument;
    }
    let allocator = alloc::arenaAllocator(self.arena);
    match *applied.base {
        case NominalType::Record(body) => {
            let mut fields: *unsafe mut [RecordField] = &mut [];
            let mut fields: *mut [RecordField] = &mut [];
            for field in body.fields {
                let fieldType = substituteRegions(self, &map, field.fieldType);
                try resolveInlineTypeViews(self, fieldType, site);
                fields.append(RecordField {
                    name: field.name,

                }, allocator);
            }
            set *applied.view = NominalType::Record(RecordType {
                regions: body.regions,
                application: applied,
                fields,
                fields: (&fields[..]) as *unsafe [RecordField],
                labeled: body.labeled,
                layout: body.layout,
                declaredLinear: body.declaredLinear,
                declaredCopy: body.declaredCopy,
            });
        }
        case NominalType::Union(body) => {
            let mut variants: *unsafe mut [UnionVariant] = &mut [];
            let mut variants: *mut [UnionVariant] = &mut [];
            for variant in body.variants {
                let valueType = substituteRegions(self, &map, variant.valueType);
                try resolveInlineTypeViews(self, valueType, site);
                variants.append(UnionVariant {
                    name: variant.name,

                }, allocator);
            }
            set *applied.view = NominalType::Union(UnionType {
                regions: body.regions,
                application: applied,
                variants,
                variants: (&variants[..]) as *unsafe [UnionVariant],
                layout: body.layout,
                valOffset: body.valOffset,
                isAllVoid: body.isAllVoid,
                declaredLinear: body.declaredLinear,
                declaredCopy: body.declaredCopy,

1466	1466		set map.arguments[i] = argument;
1467	1467		}
1468	1468		let allocator = alloc::arenaAllocator(self.arena);
1469	1469		match *applied.base {
1470	1470		case NominalType::Record(body) => {
1471		-	let mut fields: *unsafe mut [RecordField] = &mut [];
	1471	+	let mut fields: *mut [RecordField] = &mut [];
1472	1472		for field in body.fields {
1473	1473		let fieldType = substituteRegions(self, &map, field.fieldType);
1474	1474		try resolveInlineTypeViews(self, fieldType, site);
1475	1475		fields.append(RecordField {
1476	1476		name: field.name,

1479	1479		}, allocator);
1480	1480		}
1481	1481		set *applied.view = NominalType::Record(RecordType {
1482	1482		regions: body.regions,
1483	1483		application: applied,
1484		-	fields,
	1484	+	fields: (&fields[..]) as *unsafe [RecordField],
1485	1485		labeled: body.labeled,
1486	1486		layout: body.layout,
1487	1487		declaredLinear: body.declaredLinear,
1488	1488		declaredCopy: body.declaredCopy,
1489	1489		});
1490	1490		}
1491	1491		case NominalType::Union(body) => {
1492		-	let mut variants: *unsafe mut [UnionVariant] = &mut [];
	1492	+	let mut variants: *mut [UnionVariant] = &mut [];
1493	1493		for variant in body.variants {
1494	1494		let valueType = substituteRegions(self, &map, variant.valueType);
1495	1495		try resolveInlineTypeViews(self, valueType, site);
1496	1496		variants.append(UnionVariant {
1497	1497		name: variant.name,

1500	1500		}, allocator);
1501	1501		}
1502	1502		set *applied.view = NominalType::Union(UnionType {
1503	1503		regions: body.regions,
1504	1504		application: applied,
1505		-	variants,
	1505	+	variants: (&variants[..]) as *unsafe [UnionVariant],
1506	1506		layout: body.layout,
1507	1507		valOffset: body.valOffset,
1508	1508		isAllVoid: body.isAllVoid,
1509	1509		declaredLinear: body.declaredLinear,
1510	1510		declaredCopy: body.declaredCopy,