@@ -561,7 +561,7 @@ impl<'ctx> InferenceCtx<'ctx> {
561
561
ty = new_ty;
562
562
}
563
563
let defvar = & mut * d. var ;
564
- self . def_inference ( defvar, ty, ctx, builder) ;
564
+ self . deconstruct_inference ( defvar, ty, ctx, builder, true ) ;
565
565
}
566
566
NodeEnum :: Global ( g) => {
567
567
let ty = self . inference ( & mut g. exp , ctx, builder) ;
@@ -582,7 +582,7 @@ impl<'ctx> InferenceCtx<'ctx> {
582
582
}
583
583
crate :: ast:: node:: statement:: AssignVar :: Raw ( d) => {
584
584
let defvar = & mut * d;
585
- self . def_inference ( defvar, ty, ctx, builder) ;
585
+ self . deconstruct_inference ( defvar, ty, ctx, builder, false ) ;
586
586
}
587
587
}
588
588
}
@@ -1300,23 +1300,29 @@ impl<'ctx> InferenceCtx<'ctx> {
1300
1300
}
1301
1301
}
1302
1302
1303
- fn def_inference < ' a , ' b > (
1303
+ fn deconstruct_inference < ' a , ' b > (
1304
1304
& mut self ,
1305
1305
defvar : & mut DefVar ,
1306
1306
ty : SymbolType ,
1307
1307
ctx : & ' b mut Ctx < ' a > ,
1308
1308
builder : & ' b BuilderEnum < ' a , ' _ > ,
1309
+ def : bool ,
1309
1310
) {
1311
+ let f = if def {
1312
+ Self :: id_inference
1313
+ } else {
1314
+ Self :: exist_id_inference
1315
+ } ;
1310
1316
match defvar {
1311
1317
DefVar :: Identifier ( v) => {
1312
- self . id_inference ( & ty, ctx, builder, v) ;
1318
+ f ( self , & ty, ctx, builder, v) ;
1313
1319
}
1314
1320
DefVar :: TupleDeconstruct ( t) => {
1315
1321
for ( i, var) in t. var . iter_mut ( ) . enumerate ( ) {
1316
1322
let ty =
1317
1323
self . symbol_field_symbol ( ty. clone ( ) , ctx, i. to_string ( ) . into ( ) , builder) ;
1318
1324
if let Some ( ty) = ty {
1319
- self . def_inference ( & mut * var, ty, ctx, builder)
1325
+ self . deconstruct_inference ( & mut * var, ty, ctx, builder, def )
1320
1326
}
1321
1327
}
1322
1328
}
@@ -1326,13 +1332,13 @@ impl<'ctx> InferenceCtx<'ctx> {
1326
1332
crate :: ast:: node:: statement:: StructFieldDeconstructEnum :: Var ( v) => {
1327
1333
let ty = self . symbol_field_symbol ( ty. clone ( ) , ctx, v. name , builder) ;
1328
1334
if let Some ( ty) = ty {
1329
- self . id_inference ( & ty, ctx, builder, v) ;
1335
+ f ( self , & ty, ctx, builder, v) ;
1330
1336
}
1331
1337
}
1332
1338
crate :: ast:: node:: statement:: StructFieldDeconstructEnum :: Taged ( k, var) => {
1333
1339
let ty = self . symbol_field_symbol ( ty. clone ( ) , ctx, k. name , builder) ;
1334
1340
if let Some ( ty) = ty {
1335
- self . def_inference ( & mut * var, ty, ctx, builder)
1341
+ self . deconstruct_inference ( & mut * var, ty, ctx, builder, def )
1336
1342
}
1337
1343
}
1338
1344
} ;
@@ -1353,6 +1359,21 @@ impl<'ctx> InferenceCtx<'ctx> {
1353
1359
v. id = Some ( id) ;
1354
1360
self . add_symbol ( v. name , id) ;
1355
1361
}
1362
+ fn exist_id_inference < ' a , ' b > (
1363
+ & mut self ,
1364
+ ty : & SymbolType ,
1365
+ ctx : & ' b mut Ctx < ' a > ,
1366
+ builder : & ' b BuilderEnum < ' a , ' _ > ,
1367
+ v : & mut crate :: ast:: node:: primary:: VarNode ,
1368
+ ) {
1369
+ let id = self . new_key ( ) ;
1370
+ self . unify ( id, ty. clone ( ) , ctx, builder) ;
1371
+ v. id = Some ( id) ;
1372
+ self . get_symbol ( v. name ) . map ( |id2| {
1373
+ self . unify ( id2, SymbolType :: Var ( id) , ctx, builder) ;
1374
+ // self.unify_two_symbol(SymbolType::Var(id2), SymbolType::Var(id), ctx, builder);
1375
+ } ) ;
1376
+ }
1356
1377
1357
1378
fn symbol_field_symbol < ' a , ' b > (
1358
1379
& mut self ,
@@ -1378,9 +1399,6 @@ impl<'ctx> InferenceCtx<'ctx> {
1378
1399
}
1379
1400
}
1380
1401
TyInfer :: Generic ( ( tys, GenericTy :: St ( st) ) ) => {
1381
- // if f == "get" {
1382
- // eprintln!("{:?}", f);
1383
- // }
1384
1402
let mut generic_map = FxHashMap :: default ( ) ;
1385
1403
st. generic_map . iter ( ) . enumerate ( ) . for_each ( |( i, ( k, _) ) | {
1386
1404
generic_map. insert ( * k, tys[ i] ) ;
0 commit comments