New files and folders for traits

Moved common enums to common

src/librustc_codegen_llvm/abi.rs

@@ -19,7 +19,7 @@ use type_::Type;
 use type_of::{LayoutLlvmExt, PointerKind};
 use value::Value;
 
-use traits::BuilderMethods;
+use interfaces::BuilderMethods;
 
 use rustc_target::abi::{HasDataLayout, LayoutOf, Size, TyLayout, Abi as LayoutAbi};
 use rustc::ty::{self, Ty};

src/librustc_codegen_llvm/asm.rs

@@ -16,7 +16,7 @@ use builder::Builder;
 use value::Value;
 
 use rustc::hir;
-use traits::BuilderMethods;
+use interfaces::BuilderMethods;
 
 use mir::place::PlaceRef;
 use mir::operand::OperandValue;

src/librustc_codegen_llvm/base.rs

@@ -55,7 +55,7 @@ use builder::{Builder, MemFlags};
 use callee;
 use common::{C_bool, C_bytes_in_context, C_usize};
 use rustc_mir::monomorphize::item::DefPathBasedNames;
-use common::{C_struct_in_context, C_array, val_ty};
+use common::{C_struct_in_context, C_array, val_ty, IntPredicate, RealPredicate};
 use consts;
 use context::CodegenCx;
 use debuginfo;
@@ -75,7 +75,7 @@ use rustc_data_structures::small_c_str::SmallCStr;
 use rustc_data_structures::sync::Lrc;
 use rustc_data_structures::indexed_vec::Idx;
 
-use traits::{IntPredicate, RealPredicate, BuilderMethods};
+use interfaces::BuilderMethods;
 
 use std::any::Any;
 use std::cmp;

src/librustc_codegen_llvm/builder.rs

@@ -10,7 +10,7 @@
 
 use llvm::{AtomicRmwBinOp, AtomicOrdering, SynchronizationScope, AsmDialect};
 use llvm::{self, False, OperandBundleDef, BasicBlock};
-use common::*;
+use common::{self, *};
 use type_;
 use value::Value;
 use libc::{c_uint, c_char};
@@ -18,7 +18,7 @@ use rustc::ty::TyCtxt;
 use rustc::ty::layout::{Align, Size};
 use rustc::session::{config, Session};
 use rustc_data_structures::small_c_str::SmallCStr;
-use traits::{self, BuilderMethods};
+use interfaces::BuilderMethods;
 use syntax;
 
 use std::borrow::Cow;
@@ -194,7 +194,7 @@ impl BuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx> {
                   args: &[&'ll Value],
                   then: &'ll BasicBlock,
                   catch: &'ll BasicBlock,
-                  bundle: Option<&traits::OperandBundleDef<'ll, &'ll Value>>) -> &'ll Value {
+                  bundle: Option<&common::OperandBundleDef<'ll, &'ll Value>>) -> &'ll Value {
         self.count_insn("invoke");
 
         debug!("Invoke {:?} with args ({:?})",
@@ -495,7 +495,7 @@ impl BuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx> {
     fn atomic_load(
         &self,
         ptr: &'ll Value,
-        order: traits::AtomicOrdering,
+        order: common::AtomicOrdering,
         size: Size,
     ) -> &'ll Value {
         self.count_insn("load.atomic");
@@ -582,7 +582,7 @@ impl BuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx> {
     }
 
    fn atomic_store(&self, val: &'ll Value, ptr: &'ll Value,
-                   order: traits::AtomicOrdering, size: Size) {
+                   order: common::AtomicOrdering, size: Size) {
         debug!("Store {:?} -> {:?}", val, ptr);
         self.count_insn("store.atomic");
         let ptr = self.check_store(val, ptr);
@@ -708,7 +708,7 @@ impl BuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx> {
     }
 
     /* Comparisons */
-    fn icmp(&self, op: traits::IntPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
+    fn icmp(&self, op: IntPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         self.count_insn("icmp");
         let op = llvm::IntPredicate::from_generic(op);
         unsafe {
@@ -716,7 +716,7 @@ impl BuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
     }
 
-    fn fcmp(&self, op: traits::RealPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
+    fn fcmp(&self, op: RealPredicate, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         self.count_insn("fcmp");
         unsafe {
             llvm::LLVMBuildFCmp(self.llbuilder, op as c_uint, lhs, rhs, noname())
@@ -1066,8 +1066,8 @@ impl BuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx> {
         dst: &'ll Value,
         cmp: &'ll Value,
         src: &'ll Value,
-        order: traits::AtomicOrdering,
-        failure_order: traits::AtomicOrdering,
+        order: common::AtomicOrdering,
+        failure_order: common::AtomicOrdering,
         weak: bool,
     ) -> &'ll Value {
         let weak = if weak { llvm::True } else { llvm::False };
@@ -1085,10 +1085,10 @@ impl BuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx> {
     }
     fn atomic_rmw(
         &self,
-        op: traits::AtomicRmwBinOp,
+        op: common::AtomicRmwBinOp,
         dst: &'ll Value,
         src: &'ll Value,
-        order: traits::AtomicOrdering,
+        order: common::AtomicOrdering,
     ) -> &'ll Value {
         unsafe {
             llvm::LLVMBuildAtomicRMW(
@@ -1101,7 +1101,7 @@ impl BuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx> {
         }
     }
 
-    fn atomic_fence(&self, order: traits::AtomicOrdering, scope: traits::SynchronizationScope) {
+    fn atomic_fence(&self, order: common::AtomicOrdering, scope: common::SynchronizationScope) {
         unsafe {
             llvm::LLVMRustBuildAtomicFence(
                 self.llbuilder,
@@ -1227,7 +1227,7 @@ impl BuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx> {
     }
 
     fn call(&self, llfn: &'ll Value, args: &[&'ll Value],
-                bundle: Option<&traits::OperandBundleDef<'ll, &'ll Value>>) -> &'ll Value {
+                bundle: Option<&common::OperandBundleDef<'ll, &'ll Value>>) -> &'ll Value {
         self.count_insn("call");
 
         debug!("Call {:?} with args ({:?})",

src/librustc_codegen_llvm/common.rs

@@ -28,7 +28,7 @@ use value::Value;
 use rustc::ty::{self, Ty, TyCtxt};
 use rustc::ty::layout::{HasDataLayout, LayoutOf};
 use rustc::hir;
-use traits::{BuilderMethods, OperandBundleDef};
+use interfaces::BuilderMethods;
 
 use libc::{c_uint, c_char};
 
@@ -49,6 +49,87 @@ pub fn type_is_freeze<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>) -> bo
     ty.is_freeze(tcx, ty::ParamEnv::reveal_all(), DUMMY_SP)
 }
 
+pub struct OperandBundleDef<'a, Value : 'a> {
+    pub name: &'a str,
+    pub val: Value
+}
+
+impl OperandBundleDef<'ll, &'ll Value> {
+    pub fn new(name: &'ll str, val: &'ll Value) -> Self {
+        OperandBundleDef {
+            name,
+            val
+        }
+    }
+}
+
+pub enum IntPredicate {
+    IntEQ,
+    IntNE,
+    IntUGT,
+    IntUGE,
+    IntULT,
+    IntULE,
+    IntSGT,
+    IntSGE,
+    IntSLT,
+    IntSLE
+}
+
+#[allow(dead_code)]
+pub enum RealPredicate {
+    RealPredicateFalse,
+    RealOEQ,
+    RealOGT,
+    RealOGE,
+    RealOLT,
+    RealOLE,
+    RealONE,
+    RealORD,
+    RealUNO,
+    RealUEQ,
+    RealUGT,
+    RealUGE,
+    RealULT,
+    RealULE,
+    RealUNE,
+    RealPredicateTrue
+}
+
+pub enum AtomicRmwBinOp {
+    AtomicXchg,
+    AtomicAdd,
+    AtomicSub,
+    AtomicAnd,
+    AtomicNand,
+    AtomicOr,
+    AtomicXor,
+    AtomicMax,
+    AtomicMin,
+    AtomicUMax,
+    AtomicUMin
+}
+
+pub enum AtomicOrdering {
+    #[allow(dead_code)]
+    NotAtomic,
+    Unordered,
+    Monotonic,
+    // Consume,  // Not specified yet.
+    Acquire,
+    Release,
+    AcquireRelease,
+    SequentiallyConsistent,
+}
+
+pub enum SynchronizationScope {
+    // FIXME: figure out if this variant is needed at all.
+    #[allow(dead_code)]
+    Other,
+    SingleThread,
+    CrossThread,
+}
+
 /*
 * A note on nomenclature of linking: "extern", "foreign", and "upcall".
 *

src/librustc_codegen_llvm/debuginfo/gdb.rs

@@ -18,7 +18,7 @@ use declare;
 use rustc::session::config::DebugInfo;
 use type_::Type;
 use value::Value;
-use traits::BuilderMethods;
+use interfaces::BuilderMethods;
 
 use syntax::attr;
 

src/librustc_codegen_llvm/debuginfo/mod.rs

@@ -45,7 +45,7 @@ use syntax_pos::{self, Span, Pos};
 use syntax::ast;
 use syntax::symbol::{Symbol, InternedString};
 use rustc::ty::layout::{self, LayoutOf};
-use traits::BuilderMethods;
+use interfaces::BuilderMethods;
 
 pub mod gdb;
 mod utils;

src/librustc_codegen_llvm/debuginfo/source_loc.rs

@@ -17,7 +17,7 @@ use super::FunctionDebugContext;
 use llvm;
 use llvm::debuginfo::DIScope;
 use builder::Builder;
-use traits::BuilderMethods;
+use interfaces::BuilderMethods;
 
 use libc::c_uint;
 use syntax_pos::{Span, Pos};

src/librustc_codegen_llvm/glue.rs

@@ -20,7 +20,7 @@ use meth;
 use rustc::ty::layout::LayoutOf;
 use rustc::ty::{self, Ty};
 use value::Value;
-use traits::{IntPredicate,BuilderMethods};
+use interfaces::BuilderMethods;
 
 pub fn size_and_align_of_dst(
     bx: &Builder<'_, 'll, 'tcx>,

src/librustc_codegen_llvm/interfaces/builder.rs

@@ -14,92 +14,11 @@ use rustc::ty::TyCtxt;
 use rustc::ty::layout::{Align, Size};
 use rustc::session::Session;
 use builder::MemFlags;
-use value::Value;
 
 use std::borrow::Cow;
 use std::ops::Range;
 use syntax::ast::AsmDialect;
 
-pub struct OperandBundleDef<'a, Value : 'a> {
-    pub name: &'a str,
-    pub val: Value
-}
-
-impl OperandBundleDef<'ll, &'ll Value> {
-    pub fn new(name: &'ll str, val: &'ll Value) -> Self {
-        OperandBundleDef {
-            name,
-            val
-        }
-    }
-}
-
-pub enum IntPredicate {
-    IntEQ,
-    IntNE,
-    IntUGT,
-    IntUGE,
-    IntULT,
-    IntULE,
-    IntSGT,
-    IntSGE,
-    IntSLT,
-    IntSLE
-}
-
-#[allow(dead_code)]
-pub enum RealPredicate {
-    RealPredicateFalse,
-    RealOEQ,
-    RealOGT,
-    RealOGE,
-    RealOLT,
-    RealOLE,
-    RealONE,
-    RealORD,
-    RealUNO,
-    RealUEQ,
-    RealUGT,
-    RealUGE,
-    RealULT,
-    RealULE,
-    RealUNE,
-    RealPredicateTrue
-}
-
-pub enum AtomicRmwBinOp {
-    AtomicXchg,
-    AtomicAdd,
-    AtomicSub,
-    AtomicAnd,
-    AtomicNand,
-    AtomicOr,
-    AtomicXor,
-    AtomicMax,
-    AtomicMin,
-    AtomicUMax,
-    AtomicUMin
-}
-
-pub enum AtomicOrdering {
-    #[allow(dead_code)]
-    NotAtomic,
-    Unordered,
-    Monotonic,
-    // Consume,  // Not specified yet.
-    Acquire,
-    Release,
-    AcquireRelease,
-    SequentiallyConsistent,
-}
-
-pub enum SynchronizationScope {
-    // FIXME: figure out if this variant is needed at all.
-    #[allow(dead_code)]
-    Other,
-    SingleThread,
-    CrossThread,
-}
 
 
 pub trait BuilderMethods<'a, 'll :'a, 'tcx: 'll> {

src/librustc_codegen_llvm/interfaces/mod.rs

@@ -0,0 +1,13 @@
+// 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.
+
+mod builder;
+
+pub use self::builder::BuilderMethods;

src/librustc_codegen_llvm/intrinsic.rs

@@ -31,7 +31,7 @@ use syntax::symbol::Symbol;
 use builder::Builder;
 use value::Value;
 
-use traits::{BuilderMethods, AtomicRmwBinOp, SynchronizationScope};
+use interfaces::BuilderMethods;
 
 use rustc::session::Session;
 use syntax_pos::Span;
@@ -439,7 +439,7 @@ pub fn codegen_intrinsic_call(
         // This requires that atomic intrinsics follow a specific naming pattern:
         // "atomic_<operation>[_<ordering>]", and no ordering means SeqCst
         name if name.starts_with("atomic_") => {
-            use traits::AtomicOrdering::*;
+            use self::AtomicOrdering::*;
 
             let split: Vec<&str> = name.split('_').collect();
 

src/librustc_codegen_llvm/lib.rs

@@ -102,7 +102,7 @@ mod back {
     pub mod wasm;
 }
 
-mod traits;
+mod interfaces;
 
 mod abi;
 mod allocator;

src/librustc_codegen_llvm/llvm/ffi.rs

@@ -19,7 +19,7 @@ use libc::{c_uint, c_int, size_t, c_char};
 use libc::{c_ulonglong, c_void};
 
 use std::marker::PhantomData;
-use traits;
+use common;
 use syntax;
 
 use super::RustString;
@@ -144,18 +144,18 @@ pub enum IntPredicate {
 }
 
 impl IntPredicate {
-    pub fn from_generic(intpre: traits::IntPredicate) -> Self {
+    pub fn from_generic(intpre: common::IntPredicate) -> Self {
         match intpre {
-            traits::IntPredicate::IntEQ => IntPredicate::IntEQ,
-            traits::IntPredicate::IntNE => IntPredicate::IntNE,
-            traits::IntPredicate::IntUGT => IntPredicate::IntUGT,
-            traits::IntPredicate::IntUGE => IntPredicate::IntUGE,
-            traits::IntPredicate::IntULT => IntPredicate::IntULT,
-            traits::IntPredicate::IntULE => IntPredicate::IntULE,
-            traits::IntPredicate::IntSGT => IntPredicate::IntSGT,
-            traits::IntPredicate::IntSGE => IntPredicate::IntSGE,
-            traits::IntPredicate::IntSLT => IntPredicate::IntSLT,
-            traits::IntPredicate::IntSLE => IntPredicate::IntSLE,
+            common::IntPredicate::IntEQ => IntPredicate::IntEQ,
+            common::IntPredicate::IntNE => IntPredicate::IntNE,
+            common::IntPredicate::IntUGT => IntPredicate::IntUGT,
+            common::IntPredicate::IntUGE => IntPredicate::IntUGE,
+            common::IntPredicate::IntULT => IntPredicate::IntULT,
+            common::IntPredicate::IntULE => IntPredicate::IntULE,
+            common::IntPredicate::IntSGT => IntPredicate::IntSGT,
+            common::IntPredicate::IntSGE => IntPredicate::IntSGE,
+            common::IntPredicate::IntSLT => IntPredicate::IntSLT,
+            common::IntPredicate::IntSLE => IntPredicate::IntSLE,
         }
     }
 }
@@ -183,24 +183,24 @@ pub enum RealPredicate {
 }
 
 impl RealPredicate {
-    pub fn from_generic(realpred: traits::RealPredicate) -> Self {
+    pub fn from_generic(realpred: common::RealPredicate) -> Self {
         match realpred {
-            traits::RealPredicate::RealPredicateFalse => RealPredicate::RealPredicateFalse,
-            traits::RealPredicate::RealOEQ => RealPredicate::RealOEQ,
-            traits::RealPredicate::RealOGT => RealPredicate::RealOGT,
-            traits::RealPredicate::RealOGE => RealPredicate::RealOGE,
-            traits::RealPredicate::RealOLT => RealPredicate::RealOLT,
-            traits::RealPredicate::RealOLE => RealPredicate::RealOLE,
-            traits::RealPredicate::RealONE => RealPredicate::RealONE,
-            traits::RealPredicate::RealORD => RealPredicate::RealORD,
-            traits::RealPredicate::RealUNO => RealPredicate::RealUNO,
-            traits::RealPredicate::RealUEQ => RealPredicate::RealUEQ,
-            traits::RealPredicate::RealUGT => RealPredicate::RealUGT,
-            traits::RealPredicate::RealUGE => RealPredicate::RealUGE,
-            traits::RealPredicate::RealULT => RealPredicate::RealULT,
-            traits::RealPredicate::RealULE => RealPredicate::RealULE,
-            traits::RealPredicate::RealUNE => RealPredicate::RealUNE,
-            traits::RealPredicate::RealPredicateTrue => RealPredicate::RealPredicateTrue
+            common::RealPredicate::RealPredicateFalse => RealPredicate::RealPredicateFalse,
+            common::RealPredicate::RealOEQ => RealPredicate::RealOEQ,
+            common::RealPredicate::RealOGT => RealPredicate::RealOGT,
+            common::RealPredicate::RealOGE => RealPredicate::RealOGE,
+            common::RealPredicate::RealOLT => RealPredicate::RealOLT,
+            common::RealPredicate::RealOLE => RealPredicate::RealOLE,
+            common::RealPredicate::RealONE => RealPredicate::RealONE,
+            common::RealPredicate::RealORD => RealPredicate::RealORD,
+            common::RealPredicate::RealUNO => RealPredicate::RealUNO,
+            common::RealPredicate::RealUEQ => RealPredicate::RealUEQ,
+            common::RealPredicate::RealUGT => RealPredicate::RealUGT,
+            common::RealPredicate::RealUGE => RealPredicate::RealUGE,
+            common::RealPredicate::RealULT => RealPredicate::RealULT,
+            common::RealPredicate::RealULE => RealPredicate::RealULE,
+            common::RealPredicate::RealUNE => RealPredicate::RealUNE,
+            common::RealPredicate::RealPredicateTrue => RealPredicate::RealPredicateTrue
         }
     }
 }
@@ -246,19 +246,19 @@ pub enum AtomicRmwBinOp {
 }
 
 impl AtomicRmwBinOp {
-    pub fn from_generic(op : traits::AtomicRmwBinOp) -> Self {
+    pub fn from_generic(op : common::AtomicRmwBinOp) -> Self {
         match op {
-            traits::AtomicRmwBinOp::AtomicXchg => AtomicRmwBinOp::AtomicXchg,
-            traits::AtomicRmwBinOp::AtomicAdd => AtomicRmwBinOp::AtomicAdd,
-            traits::AtomicRmwBinOp::AtomicSub => AtomicRmwBinOp::AtomicSub,
-            traits::AtomicRmwBinOp::AtomicAnd => AtomicRmwBinOp::AtomicAnd,
-            traits::AtomicRmwBinOp::AtomicNand => AtomicRmwBinOp::AtomicNand,
-            traits::AtomicRmwBinOp::AtomicOr => AtomicRmwBinOp::AtomicOr,
-            traits::AtomicRmwBinOp::AtomicXor => AtomicRmwBinOp::AtomicXor,
-            traits::AtomicRmwBinOp::AtomicMax => AtomicRmwBinOp::AtomicMax,
-            traits::AtomicRmwBinOp::AtomicMin => AtomicRmwBinOp::AtomicMin,
-            traits::AtomicRmwBinOp::AtomicUMax => AtomicRmwBinOp::AtomicUMax,
-            traits::AtomicRmwBinOp::AtomicUMin => AtomicRmwBinOp::AtomicUMin
+            common::AtomicRmwBinOp::AtomicXchg => AtomicRmwBinOp::AtomicXchg,
+            common::AtomicRmwBinOp::AtomicAdd => AtomicRmwBinOp::AtomicAdd,
+            common::AtomicRmwBinOp::AtomicSub => AtomicRmwBinOp::AtomicSub,
+            common::AtomicRmwBinOp::AtomicAnd => AtomicRmwBinOp::AtomicAnd,
+            common::AtomicRmwBinOp::AtomicNand => AtomicRmwBinOp::AtomicNand,
+            common::AtomicRmwBinOp::AtomicOr => AtomicRmwBinOp::AtomicOr,
+            common::AtomicRmwBinOp::AtomicXor => AtomicRmwBinOp::AtomicXor,
+            common::AtomicRmwBinOp::AtomicMax => AtomicRmwBinOp::AtomicMax,
+            common::AtomicRmwBinOp::AtomicMin => AtomicRmwBinOp::AtomicMin,
+            common::AtomicRmwBinOp::AtomicUMax => AtomicRmwBinOp::AtomicUMax,
+            common::AtomicRmwBinOp::AtomicUMin => AtomicRmwBinOp::AtomicUMin
         }
     }
 }
@@ -279,15 +279,15 @@ pub enum AtomicOrdering {
 }
 
 impl AtomicOrdering {
-    pub fn from_generic(ao : traits::AtomicOrdering) -> Self {
+    pub fn from_generic(ao : common::AtomicOrdering) -> Self {
         match ao {
-            traits::AtomicOrdering::NotAtomic => AtomicOrdering::NotAtomic,
-            traits::AtomicOrdering::Unordered => AtomicOrdering::Unordered,
-            traits::AtomicOrdering::Monotonic => AtomicOrdering::Monotonic,
-            traits::AtomicOrdering::Acquire => AtomicOrdering::Acquire,
-            traits::AtomicOrdering::Release => AtomicOrdering::Release,
-            traits::AtomicOrdering::AcquireRelease => AtomicOrdering::AcquireRelease,
-            traits::AtomicOrdering::SequentiallyConsistent =>
+            common::AtomicOrdering::NotAtomic => AtomicOrdering::NotAtomic,
+            common::AtomicOrdering::Unordered => AtomicOrdering::Unordered,
+            common::AtomicOrdering::Monotonic => AtomicOrdering::Monotonic,
+            common::AtomicOrdering::Acquire => AtomicOrdering::Acquire,
+            common::AtomicOrdering::Release => AtomicOrdering::Release,
+            common::AtomicOrdering::AcquireRelease => AtomicOrdering::AcquireRelease,
+            common::AtomicOrdering::SequentiallyConsistent =>
                 AtomicOrdering::SequentiallyConsistent
         }
     }
@@ -306,11 +306,11 @@ pub enum SynchronizationScope {
 }
 
 impl SynchronizationScope {
-    pub fn from_generic(sc : traits::SynchronizationScope) -> Self {
+    pub fn from_generic(sc : common::SynchronizationScope) -> Self {
         match sc {
-            traits::SynchronizationScope::Other => SynchronizationScope::Other,
-            traits::SynchronizationScope::SingleThread => SynchronizationScope::SingleThread,
-            traits::SynchronizationScope::CrossThread => SynchronizationScope::CrossThread,
+            common::SynchronizationScope::Other => SynchronizationScope::Other,
+            common::SynchronizationScope::SingleThread => SynchronizationScope::SingleThread,
+            common::SynchronizationScope::CrossThread => SynchronizationScope::CrossThread,
         }
     }
 }

src/librustc_codegen_llvm/llvm/mod.rs

@@ -28,7 +28,7 @@ use std::ffi::CStr;
 use std::cell::RefCell;
 use libc::{self, c_uint, c_char, size_t};
 use rustc_data_structures::small_c_str::SmallCStr;
-use traits;
+use common;
 
 pub mod archive_ro;
 pub mod diagnostic;
@@ -273,7 +273,7 @@ impl OperandBundleDef<'a> {
         OperandBundleDef { raw: def }
     }
 
-    pub fn from_generic(bundle : &traits::OperandBundleDef<'a, &'a Value>) -> Self {
+    pub fn from_generic(bundle : &common::OperandBundleDef<'a, &'a Value>) -> Self {
         Self::new(bundle.name, &[bundle.val])
     }
 }

src/librustc_codegen_llvm/meth.rs

@@ -17,7 +17,7 @@ use monomorphize;
 use type_::Type;
 use value::Value;
 
-use traits::BuilderMethods;
+use interfaces::BuilderMethods;
 
 use rustc::ty::{self, Ty};
 use rustc::ty::layout::HasDataLayout;

src/librustc_codegen_llvm/mir/block.rs

@@ -18,7 +18,7 @@ use abi::{Abi, ArgType, ArgTypeExt, FnType, FnTypeExt, LlvmType, PassMode};
 use base;
 use callee;
 use builder::{Builder, MemFlags};
-use common::{self, C_bool, C_str_slice, C_struct, C_u32, C_uint_big, C_undef};
+use common::{self, C_bool, C_str_slice, C_struct, C_u32, C_uint_big, C_undef, IntPredicate};
 use consts;
 use meth;
 use monomorphize;
@@ -26,7 +26,7 @@ use type_of::LayoutLlvmExt;
 use type_::Type;
 use value::Value;
 
-use traits::{IntPredicate,BuilderMethods};
+use interfaces::BuilderMethods;
 
 use syntax::symbol::Symbol;
 use syntax_pos::Pos;

src/librustc_codegen_llvm/mir/constant.rs

@@ -26,7 +26,7 @@ use type_::Type;
 use syntax::ast::Mutability;
 use syntax::source_map::Span;
 use value::Value;
-use traits::BuilderMethods;
+use interfaces::BuilderMethods;
 
 use super::super::callee;
 use super::FunctionCx;

src/librustc_codegen_llvm/mir/mod.rs

@@ -26,7 +26,7 @@ use monomorphize::Instance;
 use abi::{ArgTypeExt, FnType, FnTypeExt, PassMode};
 use type_::Type;
 use value::Value;
-use traits::BuilderMethods;
+use interfaces::BuilderMethods;
 
 use syntax_pos::{DUMMY_SP, NO_EXPANSION, BytePos, Span};
 use syntax::symbol::keywords;

src/librustc_codegen_llvm/mir/operand.rs

@@ -21,7 +21,7 @@ use type_of::LayoutLlvmExt;
 use type_::Type;
 use glue;
 
-use traits::BuilderMethods;
+use interfaces::BuilderMethods;
 
 use std::fmt;
 

src/librustc_codegen_llvm/mir/place.rs

@@ -15,7 +15,7 @@ use rustc::mir;
 use rustc::mir::tcx::PlaceTy;
 use base;
 use builder::Builder;
-use common::{CodegenCx, C_undef, C_usize, C_u8, C_u32, C_uint, C_null, C_uint_big};
+use common::{CodegenCx, C_undef, C_usize, C_u8, C_u32, C_uint, C_null, C_uint_big, IntPredicate};
 use consts;
 use type_of::LayoutLlvmExt;
 use type_::Type;
@@ -23,7 +23,7 @@ use value::Value;
 use glue;
 use mir::constant::const_alloc_to_llvm;
 
-use traits::{IntPredicate,BuilderMethods};
+use interfaces::BuilderMethods;
 
 use super::{FunctionCx, LocalRef};
 use super::operand::{OperandRef, OperandValue};

src/librustc_codegen_llvm/mir/rvalue.rs

@@ -20,14 +20,17 @@ use base;
 use builder::Builder;
 use callee;
 use common::{self, val_ty};
-use common::{C_bool, C_u8, C_i32, C_u32, C_u64, C_undef, C_null, C_usize, C_uint, C_uint_big};
+use common::{
+    C_bool, C_u8, C_i32, C_u32, C_u64, C_undef, C_null, C_usize,
+    C_uint, C_uint_big, IntPredicate, RealPredicate
+};
 use consts;
 use monomorphize;
 use type_::Type;
 use type_of::LayoutLlvmExt;
 use value::Value;
 
-use traits::{IntPredicate, RealPredicate, BuilderMethods};
+use interfaces::BuilderMethods;
 
 use super::{FunctionCx, LocalRef};
 use super::operand::{OperandRef, OperandValue};

src/librustc_codegen_llvm/mir/statement.rs

@@ -12,7 +12,7 @@ use rustc::mir;
 
 use asm;
 use builder::Builder;
-use traits::BuilderMethods;
+use interfaces::BuilderMethods;
 
 use super::FunctionCx;
 use super::LocalRef;