Skip to content

Commit 8ebf5cf

Browse files
dinfuehrdinfuehr
committed
frontend: Move more type conversion functions into Emitter
1 parent 8777e94 commit 8ebf5cf

File tree

5 files changed

+158
-112
lines changed

5 files changed

+158
-112
lines changed

‎dora-frontend/src/generator.rs

Lines changed: 46 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -317,7 +317,7 @@ impl<'a> AstBytecodeGen<'a> {
317317
let context_register = self.builder.alloc_global(BytecodeType::Ptr);
318318
let idx = self.builder.add_const_cls_types(
319319
ClassId(class_id.index().try_into().expect("overflow")),
320-
convert_tya(&self.identity_type_params()),
320+
self.emitter.convert_tya(&self.identity_type_params()),
321321
);
322322
self.builder
323323
.emit_new_object(context_register, idx, self.loc(self.span));
@@ -352,7 +352,7 @@ impl<'a> AstBytecodeGen<'a> {
352352
assert!(context_data.has_parent_slot());
353353
let idx = self.builder.add_const_field_types(
354354
ClassId(class_id.index().try_into().expect("overflow")),
355-
convert_tya(&self.identity_type_params()),
355+
self.emitter.convert_tya(&self.identity_type_params()),
356356
0,
357357
);
358358
self.builder.emit_store_field(
@@ -706,7 +706,7 @@ impl<'a> AstBytecodeGen<'a> {
706706
let enum_ = self.sa.enum_(enum_id);
707707

708708
let bc_enum_id = EnumId(enum_id.index().try_into().expect("overflow"));
709-
let bc_enum_type_params = convert_tya(enum_type_params);
709+
let bc_enum_type_params = self.emitter.convert_tya(enum_type_params);
710710

711711
let match_reg = self.alloc_temp(BytecodeType::Bool);
712712
let actual_variant_reg = self.alloc_temp(BytecodeType::Int32);
@@ -772,7 +772,7 @@ impl<'a> AstBytecodeGen<'a> {
772772
let register_ty = register_bty_from_ty(field_ty.clone());
773773
let idx = self.builder.add_const_struct_field(
774774
StructId(struct_id.index().try_into().expect("overflow")),
775-
convert_tya(struct_type_params),
775+
self.convert_tya(struct_type_params),
776776
idx as u32,
777777
);
778778
let temp_reg = self.alloc_temp(register_ty);
@@ -799,7 +799,7 @@ impl<'a> AstBytecodeGen<'a> {
799799
let register_ty = register_bty_from_ty(field_ty.clone());
800800
let idx = self.builder.add_const_field_types(
801801
ClassId(class_id.index().try_into().expect("overflow")),
802-
convert_tya(class_type_params),
802+
self.convert_tya(class_type_params),
803803
idx as u32,
804804
);
805805
let temp_reg = self.alloc_temp(register_ty);
@@ -887,7 +887,7 @@ impl<'a> AstBytecodeGen<'a> {
887887
self.builder.emit_push_register(object_reg);
888888
let fct_idx = self.builder.add_const_fct_types(
889889
FunctionId(iter_fct_id.index().try_into().expect("overflow")),
890-
convert_tya(&iter_type_params),
890+
self.convert_tya(&iter_type_params),
891891
);
892892
self.builder
893893
.emit_invoke_direct(iterator_reg, fct_idx, self.loc(stmt.expr.span()));
@@ -903,7 +903,7 @@ impl<'a> AstBytecodeGen<'a> {
903903
self.enter_block_context(stmt.id);
904904

905905
let iterator_type = for_type_info.iterator_type.clone();
906-
let iterator_type_params = convert_tya(&iterator_type.type_params());
906+
let iterator_type_params = self.convert_tya(&iterator_type.type_params());
907907

908908
self.builder.emit_push_register(iterator_reg);
909909

@@ -948,7 +948,7 @@ impl<'a> AstBytecodeGen<'a> {
948948
.try_into()
949949
.expect("overflow"),
950950
),
951-
convert_tya(&option_type_params),
951+
self.convert_tya(&option_type_params),
952952
);
953953
self.builder.emit_push_register(next_result_reg);
954954
self.builder
@@ -972,7 +972,7 @@ impl<'a> AstBytecodeGen<'a> {
972972
.try_into()
973973
.expect("overflow"),
974974
),
975-
convert_tya(&option_type_params),
975+
self.convert_tya(&option_type_params),
976976
);
977977
self.builder.emit_push_register(next_result_reg);
978978
self.builder
@@ -1141,7 +1141,7 @@ impl<'a> AstBytecodeGen<'a> {
11411141
.get(part.id())
11421142
.expect("missing toString id");
11431143

1144-
let type_params = convert_tya(&type_params);
1144+
let type_params = self.convert_tya(&type_params);
11451145

11461146
let fct_idx = self.builder.add_const_fct_types(
11471147
FunctionId(to_string_id.index().try_into().expect("overflow")),
@@ -1212,7 +1212,7 @@ impl<'a> AstBytecodeGen<'a> {
12121212
location: Location,
12131213
dest: DataDest,
12141214
) -> Register {
1215-
let type_params = convert_tya(&type_params);
1215+
let type_params = self.convert_tya(&type_params);
12161216
let enum_id = EnumId(enum_id.index().try_into().expect("overflow"));
12171217
let bty = BytecodeType::Enum(enum_id, type_params.clone());
12181218
let dest = self.ensure_register(dest, bty);
@@ -1312,7 +1312,7 @@ impl<'a> AstBytecodeGen<'a> {
13121312

13131313
let idx = self.builder.add_const_fct_types(
13141314
FunctionId(lambda_fct_id.index().try_into().expect("overflow")),
1315-
convert_tya(&self.identity_type_params()),
1315+
self.convert_tya(&self.identity_type_params()),
13161316
);
13171317
self.builder.emit_new_lambda(dest, idx, self.loc(node.span));
13181318

@@ -1396,7 +1396,7 @@ impl<'a> AstBytecodeGen<'a> {
13961396

13971397
let field_idx = self.builder.add_const_field_types(
13981398
ClassId(cls_id.index().try_into().expect("overflow")),
1399-
convert_tya(&type_params),
1399+
self.convert_tya(&type_params),
14001400
field_id.0 as u32,
14011401
);
14021402

@@ -1440,7 +1440,7 @@ impl<'a> AstBytecodeGen<'a> {
14401440
let dest = self.ensure_register(dest, ty);
14411441
let const_idx = self.builder.add_const_struct_field(
14421442
StructId(struct_id.index().try_into().expect("overflow")),
1443-
convert_tya(&type_params),
1443+
self.convert_tya(&type_params),
14441444
field_idx.0 as u32,
14451445
);
14461446
self.builder
@@ -1599,7 +1599,7 @@ impl<'a> AstBytecodeGen<'a> {
15991599

16001600
let idx = self.builder.add_const_enum_variant(
16011601
EnumId(enum_id.index().try_into().expect("overflow")),
1602-
convert_tya(&type_params),
1602+
self.convert_tya(&type_params),
16031603
variant_idx,
16041604
);
16051605
let bytecode_ty = register_bty_from_ty(enum_ty);
@@ -1635,7 +1635,7 @@ impl<'a> AstBytecodeGen<'a> {
16351635
}
16361636

16371637
let idx = self.builder.add_const_lambda(
1638-
convert_tya(&params),
1638+
self.convert_tya(&params),
16391639
self.emitter.convert_ty(return_type.clone()),
16401640
);
16411641

@@ -1680,8 +1680,8 @@ impl<'a> AstBytecodeGen<'a> {
16801680

16811681
let idx = self
16821682
.builder
1683-
.add_const_struct(struct_id, convert_tya(&type_params));
1684-
let bytecode_ty = BytecodeType::Struct(struct_id, convert_tya(type_params));
1683+
.add_const_struct(struct_id, self.convert_tya(&type_params));
1684+
let bytecode_ty = BytecodeType::Struct(struct_id, self.convert_tya(type_params));
16851685
let dest_reg = self.ensure_register(dest, bytecode_ty);
16861686
self.builder
16871687
.emit_new_struct(dest_reg, idx, self.loc(expr.span));
@@ -1722,7 +1722,7 @@ impl<'a> AstBytecodeGen<'a> {
17221722
let cls_id = ClassId(cls_id.index().try_into().expect("overflow"));
17231723
let idx = self
17241724
.builder
1725-
.add_const_cls_types(cls_id, convert_tya(type_params));
1725+
.add_const_cls_types(cls_id, self.convert_tya(type_params));
17261726
let dest_reg = self.ensure_register(dest, BytecodeType::Ptr);
17271727
self.builder
17281728
.emit_new_object_initialized(dest_reg, idx, self.loc(expr.span));
@@ -1847,7 +1847,7 @@ impl<'a> AstBytecodeGen<'a> {
18471847
let (cls_id, type_params) = ty.to_class().expect("class expected");
18481848
let cls_idx = self.builder.add_const_cls_types(
18491849
ClassId(cls_id.index().try_into().expect("overflow")),
1850-
convert_tya(&type_params),
1850+
self.convert_tya(&type_params),
18511851
);
18521852

18531853
// Store length in a register
@@ -2111,7 +2111,7 @@ impl<'a> AstBytecodeGen<'a> {
21112111
}
21122112

21132113
let subtypes = ty.tuple_subtypes().expect("tuple expected");
2114-
let idx = self.builder.add_const_tuple(convert_tya(&subtypes));
2114+
let idx = self.builder.add_const_tuple(self.convert_tya(&subtypes));
21152115
self.builder.emit_new_tuple(result, idx, self.loc(e.span));
21162116

21172117
for arg_reg in values {
@@ -2338,7 +2338,7 @@ impl<'a> AstBytecodeGen<'a> {
23382338
let (cls_id, type_params) = element_ty.to_class().expect("class expected");
23392339
let cls_idx = self.builder.add_const_cls_types(
23402340
ClassId(cls_id.index().try_into().expect("overflow")),
2341-
convert_tya(&type_params),
2341+
self.convert_tya(&type_params),
23422342
);
23432343

23442344
let array_reg = self.ensure_register(dest, BytecodeType::Ptr);
@@ -2469,7 +2469,7 @@ impl<'a> AstBytecodeGen<'a> {
24692469
let intrinsic = info.intrinsic;
24702470

24712471
let fct = self.sa.fct(info.fct_id.expect("missing method"));
2472-
let ty = fct.return_type_bty();
2472+
let ty = self.emitter.convert_ty(fct.return_type());
24732473
let dest = self.ensure_register(dest, ty);
24742474

24752475
let src = gen_expr(self, opnd, DataDest::Alloc);
@@ -2518,7 +2518,7 @@ impl<'a> AstBytecodeGen<'a> {
25182518
let fct_id = info.fct_id.expect("missing function");
25192519
let fct = self.sa.fct(fct_id);
25202520

2521-
let result_type = fct.return_type_bty();
2521+
let result_type = self.emitter.convert_ty(fct.return_type());
25222522

25232523
let dest = self.ensure_register(dest, result_type);
25242524

@@ -2611,7 +2611,7 @@ impl<'a> AstBytecodeGen<'a> {
26112611

26122612
let callee_idx = self.builder.add_const_fct_types(
26132613
FunctionId(fct_id.index().try_into().expect("overflow")),
2614-
convert_tya(&type_params),
2614+
self.convert_tya(&type_params),
26152615
);
26162616
self.builder
26172617
.emit_invoke_direct(current, callee_idx, location);
@@ -2647,7 +2647,7 @@ impl<'a> AstBytecodeGen<'a> {
26472647

26482648
let callee_idx = self.builder.add_const_fct_types(
26492649
FunctionId(fct_id.index().try_into().expect("overflow")),
2650-
convert_tya(&type_params),
2650+
self.convert_tya(&type_params),
26512651
);
26522652
let dest = self.ensure_unit_register();
26532653
self.builder.emit_invoke_direct(dest, callee_idx, location);
@@ -2672,7 +2672,7 @@ impl<'a> AstBytecodeGen<'a> {
26722672

26732673
let field_idx = self.builder.add_const_field_types(
26742674
ClassId(cls_id.index().try_into().expect("overflow")),
2675-
convert_tya(&type_params),
2675+
self.convert_tya(&type_params),
26762676
field_id.0 as u32,
26772677
);
26782678

@@ -2884,7 +2884,7 @@ impl<'a> AstBytecodeGen<'a> {
28842884
let outer_cls_id = outer_context_class.class_id();
28852885
let idx = self.builder.add_const_field_types(
28862886
ClassId(outer_cls_id.index().try_into().expect("overflow")),
2887-
convert_tya(&self.identity_type_params()),
2887+
self.convert_tya(&self.identity_type_params()),
28882888
0,
28892889
);
28902890
assert!(outer_context_class.has_parent_slot());
@@ -2905,7 +2905,7 @@ impl<'a> AstBytecodeGen<'a> {
29052905

29062906
let idx = self.builder.add_const_field_types(
29072907
ClassId(outer_cls_id.index().try_into().expect("overflow")),
2908-
convert_tya(&self.identity_type_params()),
2908+
self.convert_tya(&self.identity_type_params()),
29092909
field_id.0 as u32,
29102910
);
29112911
self.builder
@@ -3052,7 +3052,7 @@ impl<'a> AstBytecodeGen<'a> {
30523052

30533053
let idx = self.builder.add_const_field_types(
30543054
ClassId(outer_cls_id.index().try_into().expect("overflow")),
3055-
convert_tya(&self.identity_type_params()),
3055+
self.convert_tya(&self.identity_type_params()),
30563056
0,
30573057
);
30583058
self.builder
@@ -3072,7 +3072,7 @@ impl<'a> AstBytecodeGen<'a> {
30723072
.try_into()
30733073
.expect("overflow"),
30743074
),
3075-
convert_tya(&self.identity_type_params()),
3075+
self.convert_tya(&self.identity_type_params()),
30763076
field_id.0 as u32,
30773077
);
30783078
self.builder
@@ -3114,7 +3114,7 @@ impl<'a> AstBytecodeGen<'a> {
31143114
let outer_cls_id = outer_context_class.class_id();
31153115
let idx = self.builder.add_const_field_types(
31163116
ClassId(outer_cls_id.index().try_into().expect("overflow")),
3117-
convert_tya(&self.identity_type_params()),
3117+
self.convert_tya(&self.identity_type_params()),
31183118
0,
31193119
);
31203120
assert!(outer_context_class.has_parent_slot());
@@ -3135,7 +3135,7 @@ impl<'a> AstBytecodeGen<'a> {
31353135

31363136
let idx = self.builder.add_const_field_types(
31373137
ClassId(outer_cls_id.index().try_into().expect("overflow")),
3138-
convert_tya(&self.identity_type_params()),
3138+
self.convert_tya(&self.identity_type_params()),
31393139
field_id.0 as u32,
31403140
);
31413141
self.builder
@@ -3160,7 +3160,7 @@ impl<'a> AstBytecodeGen<'a> {
31603160
let field_id = field_id_from_context_idx(field_id, context_data.has_parent_slot());
31613161
let field_idx = self.builder.add_const_field_types(
31623162
ClassId(cls_id.index().try_into().expect("overflow")),
3163-
convert_tya(&self.identity_type_params()),
3163+
self.convert_tya(&self.identity_type_params()),
31643164
field_id.0 as u32,
31653165
);
31663166
self.builder
@@ -3182,7 +3182,7 @@ impl<'a> AstBytecodeGen<'a> {
31823182
let field_id = field_id_from_context_idx(field_id, context_data.has_parent_slot());
31833183
let field_idx = self.builder.add_const_field_types(
31843184
ClassId(cls_id.index().try_into().expect("overflow")),
3185-
convert_tya(&self.identity_type_params()),
3185+
self.convert_tya(&self.identity_type_params()),
31863186
field_id.0 as u32,
31873187
);
31883188
self.builder
@@ -3219,8 +3219,8 @@ impl<'a> AstBytecodeGen<'a> {
32193219
self.builder.add_const(ConstPoolEntry::Generic(
32203220
id.index() as u32,
32213221
FunctionId(fct.id().index().try_into().expect("overflow")),
3222-
convert_tya(&trait_type_params),
3223-
convert_tya(&fct_type_params),
3222+
self.convert_tya(&trait_type_params),
3223+
self.convert_tya(&fct_type_params),
32243224
))
32253225
}
32263226
CallType::GenericMethodSelf(_, fct_id, ref trait_type_params, ref fct_type_params)
@@ -3231,8 +3231,8 @@ impl<'a> AstBytecodeGen<'a> {
32313231
ref fct_type_params,
32323232
) => self.builder.add_const(ConstPoolEntry::GenericSelf(
32333233
FunctionId(fct_id.index().try_into().expect("overflow")),
3234-
convert_tya(&trait_type_params),
3235-
convert_tya(&fct_type_params),
3234+
self.convert_tya(&trait_type_params),
3235+
self.convert_tya(&fct_type_params),
32363236
)),
32373237
CallType::GenericMethodNew {
32383238
object_type,
@@ -3241,9 +3241,9 @@ impl<'a> AstBytecodeGen<'a> {
32413241
fct_type_params,
32423242
} => self.builder.add_const(ConstPoolEntry::GenericNew {
32433243
object_type: self.emitter.convert_ty(object_type.clone()),
3244-
trait_ty: convert_trait_type(&trait_ty),
3244+
trait_ty: self.emitter.convert_trait_ty(&trait_ty),
32453245
fct_id: FunctionId(fct_id.index().try_into().expect("overflow")),
3246-
fct_type_params: convert_tya(fct_type_params),
3246+
fct_type_params: self.convert_tya(fct_type_params),
32473247
}),
32483248
CallType::TraitObjectMethod(ref trait_object_ty, _) => {
32493249
self.builder.add_const(ConstPoolEntry::TraitObjectMethod(
@@ -3261,7 +3261,7 @@ impl<'a> AstBytecodeGen<'a> {
32613261
);
32623262
self.builder.add_const_fct_types(
32633263
FunctionId(fct.id().index().try_into().expect("overflow")),
3264-
convert_tya(&type_params),
3264+
self.convert_tya(&type_params),
32653265
)
32663266
}
32673267

@@ -3373,6 +3373,10 @@ impl<'a> AstBytecodeGen<'a> {
33733373
new_identity_type_params(0, self.type_params_len)
33743374
}
33753375

3376+
fn convert_tya(&self, ty: &SourceTypeArray) -> BytecodeTypeArray {
3377+
convert_tya(&ty)
3378+
}
3379+
33763380
fn ensure_unit_register(&mut self) -> Register {
33773381
if let Some(register) = self.unit_register {
33783382
return register;

‎dora-frontend/src/generator/expr.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ use dora_bytecode::{BytecodeType, BytecodeTypeArray, FunctionId, Location, Regis
22
use dora_parser::ast::{self, CmpOp};
33
use dora_parser::Span;
44

5-
use crate::generator::{convert_tya, register_bty_from_ty, AstBytecodeGen, DataDest, Label};
5+
use crate::generator::{register_bty_from_ty, AstBytecodeGen, DataDest, Label};
66
use crate::sema::{FctDefinition, FctParent, Intrinsic, Sema};
77
use crate::ty::{SourceType, SourceTypeArray};
88

@@ -403,7 +403,7 @@ pub(super) fn gen_unreachable(g: &mut AstBytecodeGen, span: Span) {
403403
let return_type = g.return_type.clone();
404404
let register_bty = register_bty_from_ty(return_type.clone());
405405
let dest = g.alloc_temp(register_bty);
406-
let fct_type_params = convert_tya(&SourceTypeArray::single(return_type));
406+
let fct_type_params = g.convert_tya(&SourceTypeArray::single(return_type));
407407
let fct_idx = g.builder.add_const_fct_types(
408408
FunctionId(
409409
g.sa.known
@@ -427,7 +427,7 @@ pub(super) fn gen_fatal_error(g: &mut AstBytecodeGen, msg: &str, span: Span) {
427427
let msg_reg = g.alloc_temp(BytecodeType::Ptr);
428428
g.builder.emit_const_string(msg_reg, msg.to_string());
429429
g.builder.emit_push_register(msg_reg);
430-
let fct_type_params = convert_tya(&SourceTypeArray::single(return_type));
430+
let fct_type_params = g.convert_tya(&SourceTypeArray::single(return_type));
431431
let fct_idx = g.builder.add_const_fct_types(
432432
FunctionId(
433433
g.sa.known

0 commit comments

Comments
 (0)