@@ -176,6 +176,7 @@ export fixup_err, fixup_err_to_str;
176
176
export assignment;
177
177
export root, to_str;
178
178
export int_ty_set_all;
179
+ export force_level, force_none, force_non_region_vars_only, force_all;
179
180
180
181
// Bitvector to represent sets of integral types
181
182
enum int_ty_set = uint;
@@ -380,18 +381,19 @@ fn compare_tys(tcx: ty::ctxt, a: ty::t, b: ty::t) -> ures {
380
381
381
382
// See comment on the type `resolve_state` below
382
383
fn resolve_shallow ( cx : infer_ctxt , a : ty:: t ,
383
- force_vars : bool ) -> fres < ty:: t > {
384
+ force_vars : force_level ) -> fres < ty:: t > {
384
385
resolver ( cx, false , force_vars) . resolve ( a)
385
386
}
386
387
387
388
// See comment on the type `resolve_state` below
388
389
fn resolve_deep_var ( cx : infer_ctxt , vid : tv_vid ,
389
- force_vars : bool ) -> fres < ty:: t > {
390
+ force_vars : force_level ) -> fres < ty:: t > {
390
391
resolver ( cx, true , force_vars) . resolve ( ty:: mk_var ( cx. tcx , vid) )
391
392
}
392
393
393
394
// See comment on the type `resolve_state` below
394
- fn resolve_deep ( cx : infer_ctxt , a : ty:: t , force_vars : bool ) -> fres < ty:: t > {
395
+ fn resolve_deep ( cx : infer_ctxt , a : ty:: t , force_vars : force_level )
396
+ -> fres < ty:: t > {
395
397
resolver ( cx, true , force_vars) . resolve ( a)
396
398
}
397
399
@@ -618,7 +620,7 @@ impl methods for infer_ctxt {
618
620
}
619
621
620
622
fn resolve_type_vars_if_possible ( typ : ty:: t ) -> ty:: t {
621
- alt infer:: resolve_deep ( self , typ, false ) {
623
+ alt infer:: resolve_deep ( self , typ, force_none ) {
622
624
result:: ok ( new_type) { ret new_type; }
623
625
result:: err ( _) { ret typ; }
624
626
}
@@ -995,20 +997,34 @@ impl unify_methods for infer_ctxt {
995
997
// A <: [B] and B <: int, then shallow resolution on A would yield
996
998
// [B]. Deep resolution, on the other hand, would yield [int].
997
999
//
998
- // But there is one more knob: the force_vars variable controls the
999
- // behavior in the face of unconstrained variables. If it is true,
1000
- // then unconstrained variables result in an error.
1000
+ // But there is one more knob: the `force_level` variable controls
1001
+ // the behavior in the face of unconstrained type and region
1002
+ // variables.
1003
+
1004
+ enum force_level {
1005
+ // Any unconstrained variables are OK.
1006
+ force_none,
1007
+
1008
+ // Unconstrained region vars are OK; unconstrained ty vars and
1009
+ // integral ty vars result in an error.
1010
+ force_non_region_vars_only,
1011
+
1012
+ // Any unconstrained variables result in an error.
1013
+ force_all,
1014
+ }
1015
+
1001
1016
1002
1017
type resolve_state = @{
1003
1018
infcx : infer_ctxt,
1004
1019
deep : bool,
1005
- force_vars: bool ,
1020
+ force_vars : force_level ,
1006
1021
mut err: option < fixup_err > ,
1007
1022
mut r_seen : [ region_vid] ,
1008
1023
mut v_seen : [ tv_vid]
1009
1024
} ;
1010
1025
1011
- fn resolver( infcx: infer_ctxt, deep: bool, fvars: bool ) -> resolve_state {
1026
+ fn resolver( infcx: infer_ctxt, deep: bool , fvars: force_level)
1027
+ -> resolve_state {
1012
1028
@{ infcx: infcx,
1013
1029
deep: deep,
1014
1030
force_vars: fvars,
@@ -1021,7 +1037,7 @@ impl methods for resolve_state {
1021
1037
fn resolve( typ: ty:: t) -> fres<ty:: t> {
1022
1038
self . err = none;
1023
1039
1024
- #debug[ "Resolving %s (deep=%b, force_vars=%b )" ,
1040
+ #debug[ "Resolving %s (deep=%b, force_vars=%? )" ,
1025
1041
ty_to_str( self . infcx. tcx, typ) ,
1026
1042
self . deep,
1027
1043
self . force_vars] ;
@@ -1034,7 +1050,7 @@ impl methods for resolve_state {
1034
1050
assert vec:: is_empty( self . v_seen) && vec:: is_empty( self . r_seen) ;
1035
1051
alt self. err {
1036
1052
none {
1037
- #debug[ "Resolved to %s (deep=%b, force_vars=%b )" ,
1053
+ #debug[ "Resolved to %s (deep=%b, force_vars=%? )" ,
1038
1054
ty_to_str( self . infcx. tcx, rty) ,
1039
1055
self . deep,
1040
1056
self . force_vars] ;
@@ -1095,8 +1111,11 @@ impl methods for resolve_state {
1095
1111
{ ub : _, lb : some( t) } { self . resolve_region( t) }
1096
1112
{ ub: some( t) , lb: _ } { self . resolve_region( t) }
1097
1113
{ ub: none, lb: none } {
1098
- if self . force_vars {
1114
+ alt self. force_vars {
1115
+ force_all {
1099
1116
self . err = some( unresolved_region( rid) ) ;
1117
+ }
1118
+ _ { /* ok */ }
1100
1119
}
1101
1120
ty:: re_var( rid)
1102
1121
}
@@ -1127,8 +1146,11 @@ impl methods for resolve_state {
1127
1146
{ ub: some( t) , lb: _ } { self . resolve1( t) }
1128
1147
{ ub: _, lb: some( t) } { self . resolve1( t) }
1129
1148
{ ub: none, lb: none } {
1130
- if self . force_vars {
1149
+ alt self. force_vars {
1150
+ force_non_region_vars_only | force_all {
1131
1151
self. err = some( unresolved_ty( vid) ) ;
1152
+ }
1153
+ force_none { /* ok */ }
1132
1154
}
1133
1155
ty:: mk_var( tcx, vid)
1134
1156
}
@@ -1146,21 +1168,23 @@ impl methods for resolve_state {
1146
1168
alt single_type_contained_in( self . infcx. tcx, pt) {
1147
1169
some( t) { t }
1148
1170
none {
1149
- if self. force_vars {
1171
+ alt self. force_vars {
1172
+ force_non_region_vars_only | force_all {
1150
1173
// As a last resort, default to int.
1151
1174
let ty = ty:: mk_int( self . infcx. tcx) ;
1152
1175
self . infcx. set(
1153
1176
self . infcx. tvib, vid,
1154
1177
root( convert_integral_ty_to_int_ty_set( self . infcx. tcx,
1155
1178
ty) ) ) ;
1156
1179
ty
1157
- } else {
1180
+ }
1181
+ force_none {
1158
1182
ty : : mk_var_integral( self . infcx. tcx, vid)
1183
+ }
1159
1184
}
1160
1185
}
1161
1186
}
1162
1187
}
1163
-
1164
1188
}
1165
1189
1166
1190
// ______________________________________________________________________
0 commit comments