Implement ConstValue::InferVar and friends

varkor · varkor · commit 550999142899 · 2018-08-23T18:52:16.000+01:00
diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs
@@ -401,6 +401,9 @@ for ::mir::interpret::ConstValue<'gcx> {
             Param(ref param) => {
                 param.hash_stable(hcx, hasher);
             }
+            InferVar(vid) => {
+                vid.hash_stable(hcx, hasher);
+            }
         }
     }
 }
@@ -910,7 +913,6 @@ for ty::TyKind<'gcx>
 
 impl_stable_hash_for!(enum ty::InferTy {
     TyVar(a),
-    ConstVar(a),
     IntVar(a),
     FloatVar(a),
     FreshTy(a),
@@ -1298,7 +1300,6 @@ impl_stable_hash_for!(enum infer::canonical::CanonicalVarKind {
 
 impl_stable_hash_for!(enum infer::canonical::CanonicalTyVarKind {
     General,
-    Const,
     Int,
     Float
 });
diff --git a/src/librustc/infer/canonical/mod.rs b/src/librustc/infer/canonical/mod.rs
@@ -110,9 +110,6 @@ pub enum CanonicalTyVarKind {
     /// General type variable `?T` that can be unified with arbitrary types.
     General,
 
-    /// Const type variable `?C` that can be unified with const expressions.
-    Const,
-
     /// Integral type variable `?I` (that can only be unified with integral types).
     Int,
 
@@ -247,7 +244,6 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
                     CanonicalTyVarKind::General => {
                         self.next_ty_var(TypeVariableOrigin::MiscVariable(span))
                     }
-                    CanonicalTyVarKind::Const => self.tcx.mk_const_var(self.next_const_var_id()),
                     CanonicalTyVarKind::Int => self.tcx.mk_int_var(self.next_int_var_id()),
                     CanonicalTyVarKind::Float => self.tcx.mk_float_var(self.next_float_var_id()),
                 };
diff --git a/src/librustc/infer/freshen.rs b/src/librustc/infer/freshen.rs
@@ -141,17 +141,7 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for TypeFreshener<'a, 'gcx, 'tcx> {
                     ty::FreshTy)
             }
 
-            ty::Infer(ty::ConstVar(v)) => {
-                self.freshen(
-                    self.infcx.const_unification_table.borrow_mut()
-                        .probe_value(v)
-                        .map(|v| v.to_type(tcx)),
-                    ty::ConstVar(v),
-                    ty::FreshIntTy
-                )
-            }
-
-            ty::Infer(ty::IntVar(v)) => {
+            ty::TyInfer(ty::IntVar(v)) => {
                 self.freshen(
                     self.infcx.int_unification_table.borrow_mut()
                                                     .probe_value(v)
diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs
@@ -902,8 +902,9 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         self.tcx.mk_ty_var(self.next_ty_var_id(true, origin))
     }
 
-    pub fn next_const_var(&self) -> Ty<'tcx> {
-        self.tcx.mk_const_var(self.next_const_var_id())
+    pub fn next_const_var(&self, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
+        // TODO(const_generics): do we need this function?
+        self.tcx.mk_const_var(self.next_const_var_id(), ty)
     }
 
     pub fn next_const_var_id(&self) -> ConstVid {
@@ -950,7 +951,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
 
     pub fn var_for_def(&self,
                        span: Span,
-                       param: &ty::GenericParamDef)
+                       param: &ty::GenericParamDef<'tcx>)
                        -> Kind<'tcx> {
         match param.kind {
             GenericParamDefKind::Lifetime => {
@@ -971,22 +972,17 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                     self.type_variables
                         .borrow_mut()
                         .new_var(self.universe(),
-                                    false,
-                                    TypeVariableOrigin::TypeParameterDefinition(span, param.name));
+                                 false,
+                                 TypeVariableOrigin::TypeParameterDefinition(span, param.name));
 
                 self.tcx.mk_ty_var(ty_var_id).into()
             }
-            GenericParamDefKind::Const { .. } => {
-                let _ty_var_id =
-                    self.type_variables
+            GenericParamDefKind::Const { ty } => {
+                let const_var_id =
+                    self.const_unification_table
                         .borrow_mut()
-                        .new_var(
-                            self.universe(),
-                            false,
-                            TypeVariableOrigin::ConstParameterDefinition(span, param.name)
-                        );
-                //self.tcx.mk_const(ty_var_id).into()
-                unimplemented!()
+                        .new_key(None);
+                 self.tcx.mk_const_var(const_var_id, ty).into()
             }
         }
     }
diff --git a/src/librustc/mir/interpret/value.rs b/src/librustc/mir/interpret/value.rs
@@ -16,6 +16,8 @@ pub enum ConstValue<'tcx> {
     Unevaluated(DefId, &'tcx Substs<'tcx>),
     /// A const generic parameter.
     Param(ty::ParamConst),
+    /// Infer the value of the const.
+    InferVar(ty::ConstVid),
     /// Used only for types with layout::abi::Scalar ABI and ZSTs
     ///
     /// Not using the enum `Value` to encode that this must not be `Undef`
@@ -36,6 +38,7 @@ impl<'tcx> ConstValue<'tcx> {
             ConstValue::ByRef(..) |
             ConstValue::ScalarPair(..) => None,
             ConstValue::Param(_) => unimplemented!(), // TODO(const_generics)
+            ConstValue::InferVar(_) => unimplemented!(), // TODO(const_generics)
             ConstValue::Scalar(val) => Some(val),
         }
     }
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
@@ -2529,8 +2529,11 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         self.mk_infer(TyVar(v))
     }
 
-    pub fn mk_const_var(self, v: ConstVid) -> Ty<'tcx> {
-        self.mk_infer(ConstVar(v))
+    pub fn mk_const_var(self, v: ConstVid, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
+        self.mk_const(ty::Const {
+            val: ConstValue::InferVar(v),
+            ty,
+        })
     }
 
     pub fn mk_int_var(self, v: IntVid) -> Ty<'tcx> {
diff --git a/src/librustc/ty/flags.rs b/src/librustc/ty/flags.rs
@@ -130,7 +130,6 @@ impl FlagComputation {
                     }
 
                     ty::TyVar(_) |
-                    ty::ConstVar(_) |
                     ty::IntVar(_) |
                     ty::FloatVar(_) => {
                         self.add_flags(TypeFlags::KEEP_IN_LOCAL_TCX)
diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs
@@ -1144,6 +1144,7 @@ impl<'tcx> TypeFoldable<'tcx> for ConstValue<'tcx> {
                 ConstValue::Unevaluated(def_id, substs.fold_with(folder))
             }
             ConstValue::Param(param) => ConstValue::Param(param),
+            ConstValue::InferVar(vid) => ConstValue::InferVar(vid),
         }
     }
 
@@ -1152,6 +1153,7 @@ impl<'tcx> TypeFoldable<'tcx> for ConstValue<'tcx> {
             ConstValue::Scalar(_) |
             ConstValue::ScalarPair(_, _) |
             ConstValue::Param(_) | // TODO(const_generics)
+            ConstValue::InferVar(_) | // TODO(const_generics)
             ConstValue::ByRef(_, _) => false,
             ConstValue::Unevaluated(_, substs) => substs.visit_with(visitor),
         }
diff --git a/src/librustc/ty/sty.rs b/src/librustc/ty/sty.rs
@@ -1228,7 +1228,6 @@ impl From<RegionVid> for usize {
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, RustcEncodable, RustcDecodable)]
 pub enum InferTy {
     TyVar(TyVid),
-    ConstVar(ConstVid),
     IntVar(IntVid),
     FloatVar(FloatVid),
 
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
@@ -950,7 +950,6 @@ define_print! {
             } else {
                 match *self {
                     ty::TyVar(_) => write!(f, "_"),
-                    ty::ConstVar(_) => write!(f, "{}", "{const}"),
                     ty::IntVar(_) => write!(f, "{}", "{integer}"),
                     ty::FloatVar(_) => write!(f, "{}", "{float}"),
                     ty::CanonicalTy(_) => write!(f, "_"),
@@ -964,7 +963,6 @@ define_print! {
         debug {
             match *self {
                 ty::TyVar(ref v) => write!(f, "{:?}", v),
-                ty::ConstVar(ref v) => write!(f, "{:?}", v),
                 ty::IntVar(ref v) => write!(f, "{:?}", v),
                 ty::FloatVar(ref v) => write!(f, "{:?}", v),
                 ty::CanonicalTy(v) => write!(f, "?{:?}", v.index()),
diff --git a/src/librustc_codegen_llvm/mir/operand.rs b/src/librustc_codegen_llvm/mir/operand.rs
@@ -91,6 +91,7 @@ impl OperandRef<'ll, 'tcx> {
         let val = match val.val {
             ConstValue::Unevaluated(..) => bug!(),
             ConstValue::Param(_) => unimplemented!(), // TODO(const_generics)
+            ConstValue::InferVar(_) => unimplemented!(), // TODO(const_generics)
             ConstValue::Scalar(x) => {
                 let scalar = match layout.abi {
                     layout::Abi::Scalar(ref x) => x,
diff --git a/src/librustc_mir/hair/pattern/_match.rs b/src/librustc_mir/hair/pattern/_match.rs
@@ -1338,7 +1338,8 @@ fn slice_pat_covered_by_constructor<'tcx>(
                 ConstValue::Unevaluated(..) |
                 ConstValue::ByRef(..) => bug!("unexpected ConstValue: {:?}", const_val),
                 ConstValue::Scalar(val) | ConstValue::ScalarPair(val, _) => val,
-                ConstValue::Param(_) => unimplemented!(), // TODO(const_generics)
+                ConstValue::Param(_) | // TODO(const_generics)
+                ConstValue::InferVar(_) => unimplemented!(), // TODO(const_generics)
             };
             if let Ok(ptr) = val.to_ptr() {
                 let is_array_ptr = const_val.ty
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
@@ -56,7 +56,7 @@ pub trait AstConv<'gcx, 'tcx> {
 
     /// Same as ty_infer, but with a known type parameter definition.
     fn ty_infer_for_def(&self,
-                        _def: &ty::GenericParamDef,
+                        _def: &ty::GenericParamDef<'tcx>,
                         span: Span) -> Ty<'tcx> {
         self.ty_infer(span)
     }
@@ -1559,6 +1559,10 @@ impl<'o, 'gcx: 'tcx, 'tcx> dyn AstConv<'gcx, 'tcx>+'o {
         result_ty
     }
 
+    pub fn ast_const_to_const(&self, _ct: &hir::ConstArg, _ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
+        unimplemented!() // TODO(const_generics)
+    }
+
     pub fn impl_trait_ty_to_ty(
         &self,
         def_id: DefId,
diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
@@ -1857,7 +1857,7 @@ impl<'a, 'gcx, 'tcx> AstConv<'gcx, 'tcx> for FnCtxt<'a, 'gcx, 'tcx> {
     }
 
     fn ty_infer_for_def(&self,
-                        def: &ty::GenericParamDef,
+                        def: &ty::GenericParamDef<'tcx>,
                         span: Span) -> Ty<'tcx> {
         if let UnpackedKind::Type(ty) = self.var_for_def(span, def).unpack() {
             return ty;
@@ -2232,6 +2232,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
         t
     }
 
+    pub fn to_const(&self, ast_c: &hir::ConstArg, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
+        AstConv::ast_const_to_const(self, ast_c, ty)
+    }
+
     pub fn node_ty(&self, id: hir::HirId) -> Ty<'tcx> {
         match self.tables.borrow().node_types().get(id) {
             Some(&t) => t,
@@ -5042,7 +5046,19 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
                     }
                     GenericParamDefKind::Const { .. } => {
                         // FIXME(varkor)
-                        unimplemented!()
+                        if let Some((_, generics)) = segment {
+                            let own_counts = generics.own_counts();
+                            i -= own_counts.lifetimes + own_counts.types;
+                        }
+
+                        if let Some(ct) = consts.get(i) {
+                            // A provided const parameter.
+                            self.to_const(ct, ty).into()
+                        } else {
+                            // FIXME(const_generics:defaults)
+                            // No const parameters were provided, we can infer all.
+                            self.var_for_def(span, param)
+                        }
                     }
                 }
             },

Original file line number	Diff line number	Diff line change
`@@ -401,6 +401,9 @@ for ::mir::interpret::ConstValue<'gcx> {`
`401`	`401`	`Param(ref param) => {`
`402`	`402`	`param.hash_stable(hcx, hasher);`
`403`	`403`	`}`
	`404`	`+ InferVar(vid) => {`
	`405`	`+ vid.hash_stable(hcx, hasher);`
	`406`	`+ }`
`404`	`407`	`}`
`405`	`408`	`}`
`406`	`409`	`}`
`@@ -910,7 +913,6 @@ for ty::TyKind<'gcx>`
`910`	`913`
`911`	`914`	`impl_stable_hash_for!(enum ty::InferTy {`
`912`	`915`	`TyVar(a),`
`913`		`- ConstVar(a),`
`914`	`916`	`IntVar(a),`
`915`	`917`	`FloatVar(a),`
`916`	`918`	`FreshTy(a),`
`@@ -1298,7 +1300,6 @@ impl_stable_hash_for!(enum infer::canonical::CanonicalVarKind {`
`1298`	`1300`
`1299`	`1301`	`impl_stable_hash_for!(enum infer::canonical::CanonicalTyVarKind {`
`1300`	`1302`	`General,`
`1301`		`- Const,`
`1302`	`1303`	`Int,`
`1303`	`1304`	`Float`
`1304`	`1305`	`});`
Original file line number	Diff line number	Diff line change
`@@ -2529,8 +2529,11 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {`
`2529`	`2529`	`self.mk_infer(TyVar(v))`
`2530`	`2530`	`}`
`2531`	`2531`
`2532`		`- pub fn mk_const_var(self, v: ConstVid) -> Ty<'tcx> {`
`2533`		`- self.mk_infer(ConstVar(v))`
	`2532`	`+ pub fn mk_const_var(self, v: ConstVid, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {`
	`2533`	`+ self.mk_const(ty::Const {`
	`2534`	`+ val: ConstValue::InferVar(v),`
	`2535`	`+ ty,`
	`2536`	`+ })`
`2534`	`2537`	`}`
`2535`	`2538`
`2536`	`2539`	`pub fn mk_int_var(self, v: IntVid) -> Ty<'tcx> {`
Original file line number	Diff line number	Diff line change
`@@ -130,7 +130,6 @@ impl FlagComputation {`
`130`	`130`	`}`
`131`	`131`
`132`	`132`	`ty::TyVar(_) \|`
`133`		`- ty::ConstVar(_) \|`
`134`	`133`	`ty::IntVar(_) \|`
`135`	`134`	`ty::FloatVar(_) => {`
`136`	`135`	`self.add_flags(TypeFlags::KEEP_IN_LOCAL_TCX)`
Original file line number	Diff line number	Diff line change
`@@ -1144,6 +1144,7 @@ impl<'tcx> TypeFoldable<'tcx> for ConstValue<'tcx> {`
`1144`	`1144`	`ConstValue::Unevaluated(def_id, substs.fold_with(folder))`
`1145`	`1145`	`}`
`1146`	`1146`	`ConstValue::Param(param) => ConstValue::Param(param),`
	`1147`	`+ ConstValue::InferVar(vid) => ConstValue::InferVar(vid),`
`1147`	`1148`	`}`
`1148`	`1149`	`}`
`1149`	`1150`
`@@ -1152,6 +1153,7 @@ impl<'tcx> TypeFoldable<'tcx> for ConstValue<'tcx> {`
`1152`	`1153`	`ConstValue::Scalar(_) \|`
`1153`	`1154`	`ConstValue::ScalarPair(_, _) \|`
`1154`	`1155`	`ConstValue::Param(_) \| // TODO(const_generics)`
	`1156`	`+ ConstValue::InferVar(_) \| // TODO(const_generics)`
`1155`	`1157`	`ConstValue::ByRef(_, _) => false,`
`1156`	`1158`	`ConstValue::Unevaluated(_, substs) => substs.visit_with(visitor),`
`1157`	`1159`	`}`