Traitified IntrinsicCallMethods

Author: denismerigoux

src/librustc_codegen_llvm/attributes.rs

@@ -33,7 +33,7 @@ use value::Value;
 
 /// Mark LLVM function to use provided inline heuristic.
 #[inline]
-pub fn inline(cx: &CodegenCx<'ll, '_>, val: &'ll Value, inline: InlineAttr) {
+pub fn inline(cx: &CodegenCx<'ll, '_, &'ll Value>, val: &'ll Value, inline: InlineAttr) {
     use self::InlineAttr::*;
     match inline {
         Hint   => Attribute::InlineHint.apply_llfn(Function, val),

src/librustc_codegen_llvm/base.rs

@@ -73,7 +73,7 @@ use CrateInfo;
 use rustc_data_structures::small_c_str::SmallCStr;
 use rustc_data_structures::sync::Lrc;
 
-use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods, Backend, DerivedIntrinsicMethods};
+use interfaces::*;
 
 use std::any::Any;
 use std::ffi::CString;
@@ -409,7 +409,7 @@ pub fn from_immediate<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll ,
     }
 }
 
-pub fn to_immediate<'a, 'll, 'tcx, Builder : BuilderMethods<'a, 'll, 'tcx>>(
+pub fn to_immediate<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Builder,
     val: <Builder::CodegenCx as Backend>::Value,
     layout: layout::TyLayout,
@@ -420,7 +420,7 @@ pub fn to_immediate<'a, 'll, 'tcx, Builder : BuilderMethods<'a, 'll, 'tcx>>(
     val
 }
 
-pub fn to_immediate_scalar<'a, 'll, 'tcx, Builder : BuilderMethods<'a, 'll, 'tcx>>(
+pub fn to_immediate_scalar<'a, 'll :'a, 'tcx :'ll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
     bx: &Builder,
     val: <Builder::CodegenCx as Backend>::Value,
     scalar: &layout::Scalar,

src/librustc_codegen_llvm/builder.rs

@@ -19,7 +19,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 interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods, DerivedIntrinsicMethods};
+use interfaces::*;
 use syntax;
 
 use std::borrow::Cow;
@@ -56,10 +56,12 @@ bitflags! {
     }
 }
 
-impl BuilderMethods<'a, 'll, 'tcx>
-    for Builder<'a, 'll, 'tcx, &'ll Value> {
-
+impl<'a, 'll: 'a, 'tcx: 'll> HasCodegen<'a> for Builder<'a, 'll, 'tcx, &'ll Value> {
     type CodegenCx = CodegenCx<'ll, 'tcx, &'ll Value>;
+}
+
+impl<'a, 'll: 'a, 'tcx: 'll> BuilderMethods<'a, 'll, 'tcx>
+    for Builder<'a, 'll, 'tcx, &'ll Value> {
 
     fn new_block<'b>(
         cx: &'a CodegenCx<'ll, 'tcx, &'ll Value>,

src/librustc_codegen_llvm/consts.rs

@@ -274,8 +274,8 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
                 // This item is external but not foreign, i.e. it originates from an external Rust
                 // crate. Since we don't know whether this crate will be linked dynamically or
                 // statically in the final application, we always mark such symbols as 'dllimport'.
-                // If final linkage happens to be static, we rely on compiler-emitted __imp_ stubs to
-                // make things work.
+                // If final linkage happens to be static, we rely on compiler-emitted __imp_ stubs
+                // to make things work.
                 //
                 // However, in some scenarios we defer emission of statics to downstream
                 // crates, so there are cases where a static with an upstream DefId

src/librustc_codegen_llvm/context.rs

@@ -23,8 +23,7 @@ use value::Value;
 use monomorphize::partitioning::CodegenUnit;
 use type_::Type;
 use type_of::PointeeInfo;
-use interfaces::{BaseTypeMethods, DerivedTypeMethods,
-    IntrinsicMethods, BaseIntrinsicMethods, DerivedIntrinsicMethods};
+use interfaces::{BaseTypeMethods, DerivedTypeMethods, IntrinsicDeclarationMethods};
 
 use rustc_data_structures::base_n;
 use rustc_data_structures::small_c_str::SmallCStr;
@@ -324,9 +323,7 @@ impl<'b, 'tcx> CodegenCx<'b, 'tcx, &'b Value> {
     }
 }
 
-impl BaseIntrinsicMethods for CodegenCx<'b, 'tcx, &'b Value> {}
-
-impl DerivedIntrinsicMethods for CodegenCx<'b, 'tcx, &'b Value> {
+impl IntrinsicDeclarationMethods for CodegenCx<'b, 'tcx, &'b Value> {
     fn get_intrinsic(&self, key: &str) -> &'b Value {
         if let Some(v) = self.intrinsics.borrow().get(key).cloned() {
             return v;
@@ -642,8 +639,6 @@ impl DerivedIntrinsicMethods for CodegenCx<'b, 'tcx, &'b Value> {
     }
 }
 
-impl IntrinsicMethods for CodegenCx<'b, 'tcx, &'b Value> {}
-
 impl<'b, 'tcx> CodegenCx<'b, 'tcx, &'b Value> {
     /// Generate a new symbol name with the given prefix. This symbol name must
     /// only be used for definitions with `internal` or `private` linkage.