Stub methods in infer

varkor · yodaldevoid · varkor · commit 63b7572d0df9 · 2019-03-05T22:10:02.000Z
Co-Authored-By: Gabriel Smith &lt;yodaldevoid@users.noreply.github.com&gt;
diff --git a/src/librustc/infer/canonical/mod.rs b/src/librustc/infer/canonical/mod.rs
@@ -443,6 +443,9 @@ impl<'tcx> CanonicalVarValues<'tcx> {
                     UnpackedKind::Lifetime(..) => tcx.mk_region(
                         ty::ReLateBound(ty::INNERMOST, ty::BoundRegion::BrAnon(i))
                     ).into(),
+                    UnpackedKind::Const(..) => {
+                        unimplemented!() // FIXME(const_generics)
+                    }
                 })
                 .collect()
         }
diff --git a/src/librustc/infer/canonical/query_response.rs b/src/librustc/infer/canonical/query_response.rs
@@ -315,6 +315,10 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
                     obligations.extend(ok.into_obligations());
                 }
 
+                (UnpackedKind::Const(..), UnpackedKind::Const(..)) => {
+                    unimplemented!() // FIXME(const_generics)
+                }
+
                 _ => {
                     bug!(
                         "kind mismatch, cannot unify {:?} and {:?}",
@@ -473,6 +477,9 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
                         opt_values[br.assert_bound_var()] = Some(*original_value);
                     }
                 }
+                UnpackedKind::Const(..) => {
+                    unimplemented!() // FIXME(const_generics)
+                }
             }
         }
 
@@ -568,6 +575,11 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
                                 ty::OutlivesPredicate(t1, r2)
                             )
                         ),
+                        UnpackedKind::Const(..) => {
+                            // Consts cannot outlive one another, so we don't expect to
+                            // ecounter this branch.
+                            span_bug!(cause.span, "unexpected const outlives {:?}", constraint);
+                        }
                     }
                 )
             })
@@ -602,6 +614,9 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
                         obligations
                             .extend(self.at(cause, param_env).eq(v1, v2)?.into_obligations());
                     }
+                    (UnpackedKind::Const(..), UnpackedKind::Const(..)) => {
+                        unimplemented!() // FIXME(const_generics)
+                    }
                     _ => {
                         bug!("kind mismatch, cannot unify {:?} and {:?}", value1, value2,);
                     }
diff --git a/src/librustc/infer/combine.rs b/src/librustc/infer/combine.rs
@@ -449,7 +449,7 @@ impl<'cx, 'gcx, 'tcx> TypeRelation<'cx, 'gcx, 'tcx> for Generalizer<'cx, 'gcx, '
 
                             let origin = *variables.var_origin(vid);
                             let new_var_id = variables.new_var(self.for_universe, false, origin);
-                            let u = self.tcx().mk_var(new_var_id);
+                            let u = self.tcx().mk_ty_var(new_var_id);
                             debug!("generalize: replacing original vid={:?} with new={:?}",
                                    vid, u);
                             return Ok(u);
diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs
@@ -691,17 +691,11 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     ) -> SubstsRef<'tcx> {
         let generics = self.tcx.generics_of(def_id);
         let mut num_supplied_defaults = 0;
-        let mut type_params = generics
-            .params
-            .iter()
-            .rev()
-            .filter_map(|param| match param.kind {
-                ty::GenericParamDefKind::Lifetime => None,
-                ty::GenericParamDefKind::Type { has_default, .. } => {
-                    Some((param.def_id, has_default))
-                }
-            })
-            .peekable();
+        let mut type_params = generics.params.iter().rev().filter_map(|param| match param.kind {
+            ty::GenericParamDefKind::Lifetime => None,
+            ty::GenericParamDefKind::Type { has_default, .. } => Some((param.def_id, has_default)),
+            ty::GenericParamDefKind::Const => None, // FIXME(const_generics:defaults)
+        }).peekable();
         let has_default = {
             let has_default = type_params.peek().map(|(_, has_default)| has_default);
             *has_default.unwrap_or(&false)
diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs
@@ -656,7 +656,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         type_variables
             .unsolved_variables()
             .into_iter()
-            .map(|t| self.tcx.mk_var(t))
+            .map(|t| self.tcx.mk_ty_var(t))
             .chain(
                 (0..int_unification_table.len())
                     .map(|i| ty::IntVid { index: i as u32 })
@@ -981,7 +981,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
     }
 
     pub fn next_ty_var(&self, origin: TypeVariableOrigin) -> Ty<'tcx> {
-        self.tcx.mk_var(self.next_ty_var_id(false, origin))
+        self.tcx.mk_ty_var(self.next_ty_var_id(false, origin))
     }
 
     pub fn next_ty_var_in_universe(
@@ -992,11 +992,11 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         let vid = self.type_variables
             .borrow_mut()
             .new_var(universe, false, origin);
-        self.tcx.mk_var(vid)
+        self.tcx.mk_ty_var(vid)
     }
 
     pub fn next_diverging_ty_var(&self, origin: TypeVariableOrigin) -> Ty<'tcx> {
-        self.tcx.mk_var(self.next_ty_var_id(true, origin))
+        self.tcx.mk_ty_var(self.next_ty_var_id(true, origin))
     }
 
     pub fn next_int_var_id(&self) -> IntVid {
@@ -1081,7 +1081,10 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                     TypeVariableOrigin::TypeParameterDefinition(span, param.name),
                 );
 
-                self.tcx.mk_var(ty_var_id).into()
+                self.tcx.mk_ty_var(ty_var_id).into()
+            }
+            GenericParamDefKind::Const { .. } => {
+                unimplemented!() // FIXME(const_generics)
             }
         }
     }
diff --git a/src/librustc/infer/nll_relate/mod.rs b/src/librustc/infer/nll_relate/mod.rs
@@ -310,7 +310,7 @@ where
             ty::Projection(projection_ty)
                 if D::normalization() == NormalizationStrategy::Lazy =>
             {
-                return Ok(self.relate_projection_ty(projection_ty, self.infcx.tcx.mk_var(vid)));
+                return Ok(self.relate_projection_ty(projection_ty, self.infcx.tcx.mk_ty_var(vid)));
             }
 
             _ => (),
@@ -764,7 +764,7 @@ where
                             // the universe `_universe`.
                             let new_var_id = variables.new_var(self.universe, false, origin);
 
-                            let u = self.tcx().mk_var(new_var_id);
+                            let u = self.tcx().mk_ty_var(new_var_id);
                             debug!(
                                 "generalize: replacing original vid={:?} with new={:?}",
                                 vid,

Original file line number	Diff line number	Diff line change
`@@ -315,6 +315,10 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {`
`315`	`315`	`obligations.extend(ok.into_obligations());`
`316`	`316`	`}`
`317`	`317`
	`318`	`+ (UnpackedKind::Const(..), UnpackedKind::Const(..)) => {`
	`319`	`+ unimplemented!() // FIXME(const_generics)`
	`320`	`+ }`
	`321`	`+`
`318`	`322`	`_ => {`
`319`	`323`	`bug!(`
`320`	`324`	`"kind mismatch, cannot unify {:?} and {:?}",`
`@@ -473,6 +477,9 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {`
`473`	`477`	`opt_values[br.assert_bound_var()] = Some(*original_value);`
`474`	`478`	`}`
`475`	`479`	`}`
	`480`	`+ UnpackedKind::Const(..) => {`
	`481`	`+ unimplemented!() // FIXME(const_generics)`
	`482`	`+ }`
`476`	`483`	`}`
`477`	`484`	`}`
`478`	`485`
`@@ -568,6 +575,11 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {`
`568`	`575`	`ty::OutlivesPredicate(t1, r2)`
`569`	`576`	`)`
`570`	`577`	`),`
	`578`	`+ UnpackedKind::Const(..) => {`
	`579`	`+ // Consts cannot outlive one another, so we don't expect to`
	`580`	`+ // ecounter this branch.`
	`581`	`+ span_bug!(cause.span, "unexpected const outlives {:?}", constraint);`
	`582`	`+ }`
`571`	`583`	`}`
`572`	`584`	`)`
`573`	`585`	`})`
`@@ -602,6 +614,9 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {`
`602`	`614`	`obligations`
`603`	`615`	`.extend(self.at(cause, param_env).eq(v1, v2)?.into_obligations());`
`604`	`616`	`}`
	`617`	`+ (UnpackedKind::Const(..), UnpackedKind::Const(..)) => {`
	`618`	`+ unimplemented!() // FIXME(const_generics)`
	`619`	`+ }`
`605`	`620`	`_ => {`
`606`	`621`	`bug!("kind mismatch, cannot unify {:?} and {:?}", value1, value2,);`
`607`	`622`	`}`
Original file line number	Diff line number	Diff line change
`@@ -656,7 +656,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {`
`656`	`656`	`type_variables`
`657`	`657`	`.unsolved_variables()`
`658`	`658`	`.into_iter()`
`659`		`- .map(\|t\| self.tcx.mk_var(t))`
	`659`	`+ .map(\|t\| self.tcx.mk_ty_var(t))`
`660`	`660`	`.chain(`
`661`	`661`	`(0..int_unification_table.len())`
`662`	`662`	`.map(\|i\| ty::IntVid { index: i as u32 })`
`@@ -981,7 +981,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {`
`981`	`981`	`}`
`982`	`982`
`983`	`983`	`pub fn next_ty_var(&self, origin: TypeVariableOrigin) -> Ty<'tcx> {`
`984`		`- self.tcx.mk_var(self.next_ty_var_id(false, origin))`
	`984`	`+ self.tcx.mk_ty_var(self.next_ty_var_id(false, origin))`
`985`	`985`	`}`
`986`	`986`
`987`	`987`	`pub fn next_ty_var_in_universe(`
`@@ -992,11 +992,11 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {`
`992`	`992`	`let vid = self.type_variables`
`993`	`993`	`.borrow_mut()`
`994`	`994`	`.new_var(universe, false, origin);`
`995`		`- self.tcx.mk_var(vid)`
	`995`	`+ self.tcx.mk_ty_var(vid)`
`996`	`996`	`}`
`997`	`997`
`998`	`998`	`pub fn next_diverging_ty_var(&self, origin: TypeVariableOrigin) -> Ty<'tcx> {`
`999`		`- self.tcx.mk_var(self.next_ty_var_id(true, origin))`
	`999`	`+ self.tcx.mk_ty_var(self.next_ty_var_id(true, origin))`
`1000`	`1000`	`}`
`1001`	`1001`
`1002`	`1002`	`pub fn next_int_var_id(&self) -> IntVid {`
`@@ -1081,7 +1081,10 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {`
`1081`	`1081`	`TypeVariableOrigin::TypeParameterDefinition(span, param.name),`
`1082`	`1082`	`);`
`1083`	`1083`
`1084`		`- self.tcx.mk_var(ty_var_id).into()`
	`1084`	`+ self.tcx.mk_ty_var(ty_var_id).into()`
	`1085`	`+ }`
	`1086`	`+ GenericParamDefKind::Const { .. } => {`
	`1087`	`+ unimplemented!() // FIXME(const_generics)`
`1085`	`1088`	`}`
`1086`	`1089`	`}`
`1087`	`1090`	`}`