Skip to content

Commit ba5aaa8

Browse files
lrh2000lrh2000
committed
Introduce the ! type (named "never")
1 parent 8ed81aa commit ba5aaa8

12 files changed

+180
-30
lines changed

‎gcc/rust/backend/rust-compile-context.h

+5
Original file line numberDiff line numberDiff line change
@@ -503,6 +503,11 @@ class TyTyResolveCompile : public TyTy::TyVisitor
503503
translated = compiled_type;
504504
}
505505

506+
void visit (TyTy::NeverType &) override
507+
{
508+
translated = ctx->get_backend ()->void_type ();
509+
}
510+
506511
private:
507512
TyTyResolveCompile (Context *ctx) : ctx (ctx), translated (nullptr) {}
508513

‎gcc/rust/backend/rust-compile-tyty.h

+5
Original file line numberDiff line numberDiff line change
@@ -222,6 +222,11 @@ class TyTyCompile : public TyTy::TyVisitor
222222
= backend->named_type ("str", raw_str, Linemap::predeclared_location ());
223223
}
224224

225+
void visit (TyTy::NeverType &) override
226+
{
227+
translated = backend->void_type ();
228+
}
229+
225230
private:
226231
TyTyCompile (::Backend *backend)
227232
: backend (backend), translated (nullptr),

‎gcc/rust/typecheck/rust-hir-type-check-expr.h

+5-3
Original file line numberDiff line numberDiff line change
@@ -146,7 +146,7 @@ class TypeCheckExpr : public TypeCheckBase
146146
{
147147
if (!expr.has_return_expr ())
148148
{
149-
infered = new TyTy::TupleType (expr.get_mappings ().get_hirid ());
149+
infered = new TyTy::NeverType (expr.get_mappings ().get_hirid ());
150150
return;
151151
}
152152

@@ -165,6 +165,8 @@ class TypeCheckExpr : public TypeCheckBase
165165
fn_return_tyty->append_reference (expr_ty->get_ref ());
166166
for (auto &ref : infered->get_combined_refs ())
167167
fn_return_tyty->append_reference (ref);
168+
169+
infered = new TyTy::NeverType (expr.get_mappings ().get_hirid ());
168170
}
169171

170172
void visit (HIR::CallExpr &expr) override
@@ -904,7 +906,7 @@ class TypeCheckExpr : public TypeCheckBase
904906
context->swap_head_loop_context (unified_ty);
905907
}
906908

907-
infered = new TyTy::TupleType (expr.get_mappings ().get_hirid ());
909+
infered = new TyTy::NeverType (expr.get_mappings ().get_hirid ());
908910
}
909911

910912
void visit (HIR::ContinueExpr &expr) override
@@ -916,7 +918,7 @@ class TypeCheckExpr : public TypeCheckBase
916918
return;
917919
}
918920

919-
infered = new TyTy::TupleType (expr.get_mappings ().get_hirid ());
921+
infered = new TyTy::NeverType (expr.get_mappings ().get_hirid ());
920922
}
921923

922924
void visit (HIR::BorrowExpr &expr) override

‎gcc/rust/typecheck/rust-hir-type-check-stmt.h

+6
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,12 @@ class TypeCheckStmt : public TypeCheckBase
4242
void visit (HIR::ExprStmtWithBlock &stmt) override
4343
{
4444
infered = TypeCheckExpr::Resolve (stmt.get_expr (), inside_loop);
45+
46+
if (stmt.is_unit_check_needed ())
47+
{
48+
auto unit = new TyTy::TupleType (stmt.get_mappings ().get_hirid ());
49+
infered = unit->unify (infered);
50+
}
4551
}
4652

4753
void visit (HIR::ExprStmtWithoutBlock &stmt) override

‎gcc/rust/typecheck/rust-hir-type-check.cc

+7-26
Original file line numberDiff line numberDiff line change
@@ -82,44 +82,25 @@ TypeResolution::Resolve (HIR::Crate &crate)
8282
void
8383
TypeCheckExpr::visit (HIR::BlockExpr &expr)
8484
{
85-
TyTy::BaseType *block_tyty
86-
= new TyTy::TupleType (expr.get_mappings ().get_hirid ());
87-
8885
expr.iterate_stmts ([&] (HIR::Stmt *s) mutable -> bool {
89-
bool is_final_stmt = expr.is_final_stmt (s);
90-
bool has_final_expr = expr.has_expr () && expr.tail_expr_reachable ();
91-
bool stmt_is_final_expr = is_final_stmt && !has_final_expr;
92-
9386
auto resolved = TypeCheckStmt::Resolve (s, inside_loop);
9487
if (resolved == nullptr)
9588
{
9689
rust_error_at (s->get_locus_slow (), "failure to resolve type");
9790
return false;
9891
}
9992

100-
if (stmt_is_final_expr)
101-
{
102-
delete block_tyty;
103-
block_tyty = resolved;
104-
}
105-
else if (!resolved->is_unit ())
106-
{
107-
rust_error_at (s->get_locus_slow (), "expected () got %s",
108-
resolved->as_string ().c_str ());
109-
}
110-
11193
return true;
11294
});
11395

11496
if (expr.has_expr ())
115-
{
116-
delete block_tyty;
117-
118-
block_tyty
119-
= TypeCheckExpr::Resolve (expr.get_final_expr ().get (), inside_loop);
120-
}
121-
122-
infered = block_tyty->clone ();
97+
infered
98+
= TypeCheckExpr::Resolve (expr.get_final_expr ().get (), inside_loop)
99+
->clone ();
100+
else if (expr.is_tail_reachable ())
101+
infered = new TyTy::TupleType (expr.get_mappings ().get_hirid ());
102+
else
103+
infered = new TyTy::NeverType (expr.get_mappings ().get_hirid ());
123104
}
124105

125106
// RUST_HIR_TYPE_CHECK_STRUCT_FIELD

‎gcc/rust/typecheck/rust-substitution-mapper.h

+3
Original file line numberDiff line numberDiff line change
@@ -94,6 +94,7 @@ class SubstMapper : public TyTy::TyVisitor
9494
void visit (TyTy::ReferenceType &) override { gcc_unreachable (); }
9595
void visit (TyTy::ParamType &) override { gcc_unreachable (); }
9696
void visit (TyTy::StrType &) override { gcc_unreachable (); }
97+
void visit (TyTy::NeverType &) override { gcc_unreachable (); }
9798

9899
private:
99100
SubstMapper (HirId ref, HIR::GenericArgs *generics, Location locus)
@@ -152,6 +153,7 @@ class SubstMapperInternal : public TyTy::TyVisitor
152153
void visit (TyTy::ReferenceType &) override { gcc_unreachable (); }
153154
void visit (TyTy::ParamType &) override { gcc_unreachable (); }
154155
void visit (TyTy::StrType &) override { gcc_unreachable (); }
156+
void visit (TyTy::NeverType &) override { gcc_unreachable (); }
155157

156158
private:
157159
SubstMapperInternal (HirId ref, TyTy::SubstitutionArgumentMappings &mappings)
@@ -206,6 +208,7 @@ class SubstMapperFromExisting : public TyTy::TyVisitor
206208
void visit (TyTy::ReferenceType &) override { gcc_unreachable (); }
207209
void visit (TyTy::ParamType &) override { gcc_unreachable (); }
208210
void visit (TyTy::StrType &) override { gcc_unreachable (); }
211+
void visit (TyTy::NeverType &) override { gcc_unreachable (); }
209212

210213
private:
211214
SubstMapperFromExisting (TyTy::BaseType *concrete, TyTy::BaseType *receiver)

‎gcc/rust/typecheck/rust-tycheck-dump.h

+1-1
Original file line numberDiff line numberDiff line change
@@ -107,7 +107,7 @@ class TypeResolverDump : public TypeCheckBase
107107
return true;
108108
});
109109

110-
if (expr.has_expr () && expr.tail_expr_reachable ())
110+
if (expr.has_expr ())
111111
{
112112
dump += indent ();
113113
expr.expr->accept_vis (*this);

‎gcc/rust/typecheck/rust-tyty-call.h

+2
Original file line numberDiff line numberDiff line change
@@ -53,6 +53,7 @@ class TypeCheckCallExpr : private TyVisitor
5353
void visit (ReferenceType &type) override { gcc_unreachable (); }
5454
void visit (ParamType &) override { gcc_unreachable (); }
5555
void visit (StrType &) override { gcc_unreachable (); }
56+
void visit (NeverType &) override { gcc_unreachable (); }
5657

5758
// tuple-structs
5859
void visit (ADTType &type) override;
@@ -100,6 +101,7 @@ class TypeCheckMethodCallExpr : private TyVisitor
100101
void visit (ReferenceType &type) override { gcc_unreachable (); }
101102
void visit (ParamType &) override { gcc_unreachable (); }
102103
void visit (StrType &) override { gcc_unreachable (); }
104+
void visit (NeverType &) override { gcc_unreachable (); }
103105

104106
// FIXME
105107
void visit (FnPtr &type) override { gcc_unreachable (); }

‎gcc/rust/typecheck/rust-tyty-rules.h

+92
Original file line numberDiff line numberDiff line change
@@ -242,6 +242,14 @@ class BaseRules : public TyVisitor
242242
type.as_string ().c_str ());
243243
}
244244

245+
virtual void visit (NeverType &type) override
246+
{
247+
Location ref_locus = mappings->lookup_location (type.get_ref ());
248+
rust_error_at (ref_locus, "expected [%s] got [%s]",
249+
get_base ()->as_string ().c_str (),
250+
type.as_string ().c_str ());
251+
}
252+
245253
protected:
246254
BaseRules (BaseType *base)
247255
: mappings (Analysis::Mappings::get ()),
@@ -478,6 +486,8 @@ class InferRules : public BaseRules
478486
BaseRules::visit (type);
479487
}
480488

489+
void visit (NeverType &type) override { resolved = base->clone (); }
490+
481491
private:
482492
BaseType *get_base () override { return base; }
483493

@@ -536,6 +546,8 @@ class FnRules : public BaseRules
536546
resolved->set_ref (type.get_ref ());
537547
}
538548

549+
void visit (NeverType &type) override { resolved = base->clone (); }
550+
539551
private:
540552
BaseType *get_base () override { return base; }
541553

@@ -631,6 +643,8 @@ class FnptrRules : public BaseRules
631643
resolved->set_ref (type.get_ref ());
632644
}
633645

646+
void visit (NeverType &type) override { resolved = base->clone (); }
647+
634648
private:
635649
BaseType *get_base () override { return base; }
636650

@@ -669,6 +683,8 @@ class ArrayRules : public BaseRules
669683
type.get_capacity (), TyVar (base_resolved->get_ref ()));
670684
}
671685

686+
void visit (NeverType &type) override { resolved = base->clone (); }
687+
672688
private:
673689
BaseType *get_base () override { return base; }
674690

@@ -701,6 +717,8 @@ class BoolRules : public BaseRules
701717
}
702718
}
703719

720+
void visit (NeverType &type) override { resolved = base->clone (); }
721+
704722
private:
705723
BaseType *get_base () override { return base; }
706724

@@ -739,6 +757,8 @@ class IntRules : public BaseRules
739757
= new IntType (type.get_ref (), type.get_ty_ref (), type.get_int_kind ());
740758
}
741759

760+
void visit (NeverType &type) override { resolved = base->clone (); }
761+
742762
private:
743763
BaseType *get_base () override { return base; }
744764

@@ -777,6 +797,8 @@ class UintRules : public BaseRules
777797
type.get_uint_kind ());
778798
}
779799

800+
void visit (NeverType &type) override { resolved = base->clone (); }
801+
780802
private:
781803
BaseType *get_base () override { return base; }
782804

@@ -814,6 +836,8 @@ class FloatRules : public BaseRules
814836
type.get_float_kind ());
815837
}
816838

839+
void visit (NeverType &type) override { resolved = base->clone (); }
840+
817841
private:
818842
BaseType *get_base () override { return base; }
819843

@@ -854,6 +878,8 @@ class ADTRules : public BaseRules
854878
resolved = type.clone ();
855879
}
856880

881+
void visit (NeverType &type) override { resolved = base->clone (); }
882+
857883
private:
858884
BaseType *get_base () override { return base; }
859885

@@ -895,6 +921,8 @@ class TupleRules : public BaseRules
895921
= new TyTy::TupleType (type.get_ref (), type.get_ty_ref (), fields);
896922
}
897923

924+
void visit (NeverType &type) override { resolved = base->clone (); }
925+
898926
private:
899927
BaseType *get_base () override { return base; }
900928

@@ -923,6 +951,8 @@ class USizeRules : public BaseRules
923951

924952
void visit (USizeType &type) override { resolved = type.clone (); }
925953

954+
void visit (NeverType &type) override { resolved = base->clone (); }
955+
926956
private:
927957
BaseType *get_base () override { return base; }
928958

@@ -951,6 +981,8 @@ class ISizeRules : public BaseRules
951981

952982
void visit (ISizeType &type) override { resolved = type.clone (); }
953983

984+
void visit (NeverType &type) override { resolved = base->clone (); }
985+
954986
private:
955987
BaseType *get_base () override { return base; }
956988

@@ -978,6 +1010,8 @@ class CharRules : public BaseRules
9781010

9791011
void visit (CharType &type) override { resolved = type.clone (); }
9801012

1013+
void visit (NeverType &type) override { resolved = base->clone (); }
1014+
9811015
private:
9821016
BaseType *get_base () override { return base; }
9831017

@@ -1008,6 +1042,8 @@ class ReferenceRules : public BaseRules
10081042
TyVar (base_resolved->get_ref ()));
10091043
}
10101044

1045+
void visit (NeverType &type) override { resolved = base->clone (); }
1046+
10111047
private:
10121048
BaseType *get_base () override { return base; }
10131049

@@ -1053,6 +1089,8 @@ class ParamRules : public BaseRules
10531089
resolved = type.clone ();
10541090
}
10551091

1092+
void visit (NeverType &type) override { resolved = base->clone (); }
1093+
10561094
private:
10571095
BaseType *get_base () override { return base; }
10581096

@@ -1069,12 +1107,66 @@ class StrRules : public BaseRules
10691107

10701108
void visit (StrType &type) override { resolved = type.clone (); }
10711109

1110+
void visit (NeverType &type) override { resolved = base->clone (); }
1111+
10721112
private:
10731113
BaseType *get_base () override { return base; }
10741114

10751115
StrType *base;
10761116
};
10771117

1118+
class NeverRules : public BaseRules
1119+
{
1120+
using Rust::TyTy::BaseRules::visit;
1121+
1122+
public:
1123+
NeverRules (NeverType *base) : BaseRules (base), base (base) {}
1124+
1125+
virtual void visit (TupleType &type) override { resolved = type.clone (); }
1126+
1127+
virtual void visit (ADTType &type) override { resolved = type.clone (); }
1128+
1129+
virtual void visit (InferType &type) override { resolved = type.clone (); }
1130+
1131+
virtual void visit (FnType &type) override { resolved = type.clone (); }
1132+
1133+
virtual void visit (FnPtr &type) override { resolved = type.clone (); }
1134+
1135+
virtual void visit (ArrayType &type) override { resolved = type.clone (); }
1136+
1137+
virtual void visit (BoolType &type) override { resolved = type.clone (); }
1138+
1139+
virtual void visit (IntType &type) override { resolved = type.clone (); }
1140+
1141+
virtual void visit (UintType &type) override { resolved = type.clone (); }
1142+
1143+
virtual void visit (USizeType &type) override { resolved = type.clone (); }
1144+
1145+
virtual void visit (ISizeType &type) override { resolved = type.clone (); }
1146+
1147+
virtual void visit (FloatType &type) override { resolved = type.clone (); }
1148+
1149+
virtual void visit (ErrorType &type) override { resolved = type.clone (); }
1150+
1151+
virtual void visit (CharType &type) override { resolved = type.clone (); }
1152+
1153+
virtual void visit (ReferenceType &type) override
1154+
{
1155+
resolved = type.clone ();
1156+
}
1157+
1158+
virtual void visit (ParamType &type) override { resolved = type.clone (); }
1159+
1160+
virtual void visit (StrType &type) override { resolved = type.clone (); }
1161+
1162+
virtual void visit (NeverType &type) override { resolved = type.clone (); }
1163+
1164+
private:
1165+
BaseType *get_base () override { return base; }
1166+
1167+
NeverType *base;
1168+
};
1169+
10781170
} // namespace TyTy
10791171
} // namespace Rust
10801172

‎gcc/rust/typecheck/rust-tyty-visitor.h

+1
Original file line numberDiff line numberDiff line change
@@ -44,6 +44,7 @@ class TyVisitor
4444
virtual void visit (ReferenceType &type) = 0;
4545
virtual void visit (ParamType &type) = 0;
4646
virtual void visit (StrType &type) = 0;
47+
virtual void visit (NeverType &type) = 0;
4748
};
4849

4950
} // namespace TyTy

0 commit comments

Comments
 (0)