Move ConstVariableOrigin to const_variable.rs

Author: varkor

src/librustc/infer/const_variable.rs

@@ -0,0 +1,19 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use syntax::symbol::InternedString;
+use syntax_pos::Span;
+
+/// Reasons to create a const inference variable
+#[derive(Copy, Clone, Debug)]
+pub enum ConstVariableOrigin {
+    ConstInference(Span),
+    ConstParameterDefinition(Span, InternedString),
+}

src/librustc/infer/mod.rs

@@ -46,7 +46,8 @@ use self::region_constraints::{RegionConstraintCollector, RegionSnapshot};
 use self::region_constraints::{GenericKind, VerifyBound, RegionConstraintData, VarInfos};
 use self::lexical_region_resolve::LexicalRegionResolutions;
 use self::outlives::env::OutlivesEnvironment;
-use self::type_variable::{TypeVariableOrigin, ConstVariableOrigin};
+use self::type_variable::TypeVariableOrigin;
+use self::const_variable::ConstVariableOrigin;
 use self::unify_key::ToType;
 
 pub mod anon_types;
@@ -67,6 +68,7 @@ pub mod resolve;
 mod freshen;
 mod sub;
 pub mod type_variable;
+pub mod const_variable;
 pub mod unify_key;
 
 #[must_use]

src/librustc/infer/type_variable.rs

@@ -68,14 +68,6 @@ pub enum TypeVariableOrigin {
     Generalized(ty::TyVid),
 }
 
-/// Reasons to create a type inference variable
-// TODO(const_generics): move this somewhere more sensible
-#[derive(Copy, Clone, Debug)]
-pub enum ConstVariableOrigin {
-    ConstInference(Span),
-    ConstParameterDefinition(Span, InternedString),
-}
-
 pub type TypeVariableMap = FxHashMap<ty::TyVid, TypeVariableOrigin>;
 
 struct TypeVariableData {

src/librustc/ty/instance.rs

@@ -198,8 +198,7 @@ impl<'a, 'b, 'tcx> Instance<'tcx> {
                     let f = item_type.fn_sig(tcx);
                     f.abi() == Abi::RustIntrinsic ||
                         f.abi() == Abi::PlatformIntrinsic
-                } =>
-                {
+                } => {
                     debug!(" => intrinsic");
                     ty::InstanceDef::Intrinsic(def_id)
                 }

src/librustc/ty/relate.rs

@@ -599,7 +599,6 @@ pub fn super_relate_consts<'a, 'gcx, 'tcx, R>(relation: &mut R,
     // `structural_match` types.
     // FIXME(const_generics): check for `structural_match` synthetic attribute.
     // TODO(const_generics): possibly need indirection for ByRef?
-    // TODO(const_generics): Param should be a bug here
     match (a.val, b.val) {
         (ConstValue::Infer(_), _) | (_, ConstValue::Infer(_)) => {
             // The caller should handle these cases!

src/librustc_mir/interpret/eval_context.rs

@@ -378,7 +378,11 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
         Ok(Value::new_slice(Scalar::Ptr(ptr), s.len() as u64, self.tcx.tcx))
     }
 
-    pub(super) fn resolve(&self, def_id: DefId, substs: &'tcx Substs<'tcx>) -> EvalResult<'tcx, ty::Instance<'tcx>> {
+    pub(super) fn resolve(
+        &self,
+        def_id: DefId,
+        substs: &'tcx Substs<'tcx>
+    ) -> EvalResult<'tcx, ty::Instance<'tcx>> {
         trace!("resolve: {:?}, {:#?}", def_id, substs);
         trace!("substs: {:#?}", self.substs());
         trace!("param_env: {:#?}", self.param_env);
@@ -406,7 +410,8 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
     ) -> EvalResult<'tcx, &'tcx mir::Mir<'tcx>> {
         // do not continue if typeck errors occurred (can only occur in local crate)
         let did = instance.def_id();
-        if did.is_local() && self.tcx.has_typeck_tables(did) && self.tcx.typeck_tables_of(did).tainted_by_errors {
+        if did.is_local() && self.tcx.has_typeck_tables(did)
+            && self.tcx.typeck_tables_of(did).tainted_by_errors {
             return err!(TypeckError);
         }
         trace!("load mir {:?}", instance);