Properly translate methods with foreign CC

This fixes a general issue of trying to define extern functions inside impl blocks resulting in
ICE.

Fixes #21238
Fixes #20734
Fixes #19047

2 files changed, 49 insertions, 6 deletions

diff --git a/src/librustc_trans/trans/base.rs b/src/librustc_trans/trans/base.rs
index b5393247f72..7e51c041c6e 100644
--- a/src/librustc_trans/trans/base.rs
+++ b/src/librustc_trans/trans/base.rs
@@ -2412,9 +2412,9 @@ fn register_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
                          -> ValueRef {
     if let ty::ty_bare_fn(_, ref f) = node_type.sty {
         if f.abi != Rust && f.abi != RustCall {
-            ccx.sess().span_bug(sp, &format!("only `Rust` or `rust-call` calling conventions \
-                                              are valid for this function, but it uses `{:?}`",
-                                              f.abi.name));
+            ccx.sess().span_bug(sp, &format!("only the `{}` or `{}` calling conventions are valid \
+                                              for this function; `{}` was specified",
+                                              Rust.name(), RustCall.name(), f.abi.name()));
         }
     } else {
         ccx.sess().span_bug(sp, "expected bare rust function")
@@ -2938,9 +2938,17 @@ fn register_method(ccx: &CrateContext, id: ast::NodeId,
 
     let sym = exported_name(ccx, id, mty, &m.attrs);
 
-    let llfn = register_fn(ccx, m.span, sym, id, mty);
-    set_llvm_fn_attrs(ccx, &m.attrs, llfn);
-    llfn
+    if let ty::ty_bare_fn(_, ref f) = mty.sty {
+        let llfn = if f.abi == Rust || f.abi == RustCall {
+            register_fn(ccx, m.span, sym, id, mty)
+        } else {
+            foreign::register_rust_fn_with_foreign_abi(ccx, m.span, sym, id)
+        };
+        set_llvm_fn_attrs(ccx, &m.attrs, llfn);
+        return llfn;
+    } else {
+        ccx.sess().span_bug(m.span, "expected bare rust function");
+    }
 }
 
 pub fn crate_ctxt_to_encode_parms<'a, 'tcx>(cx: &'a SharedCrateContext<'tcx>,
diff --git a/src/test/run-pass/extern-methods.rs b/src/test/run-pass/extern-methods.rs
new file mode 100644
index 00000000000..0cd53184e6c
--- /dev/null
+++ b/src/test/run-pass/extern-methods.rs
@@ -0,0 +1,35 @@
+// Copyright 2015 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.
+trait A {
+    extern "fastcall" fn test1(i: i32);
+    extern fn test2(i: i32);
+}
+
+struct S;
+impl S {
+    extern "stdcall" fn test3(i: i32) {
+        assert_eq!(i, 3);
+    }
+}
+
+impl A for S {
+    extern "fastcall" fn test1(i: i32) {
+        assert_eq!(i, 1);
+    }
+    extern fn test2(i: i32) {
+        assert_eq!(i, 2);
+    }
+}
+
+fn main() {
+    <S as A>::test1(1);
+    <S as A>::test2(2);
+    S::test3(3);
+}