All uses of extern fn should mean extern "C" fn. Closes #9309.

Author: nrc

src/librustc/middle/typeck/infer/combine.rs

@@ -500,6 +500,7 @@ pub fn super_tys<C:Combine>(this: &C, a: ty::t, b: ty::t) -> cres<ty::t> {
       (&ty::ty_trait(a_id, ref a_substs, a_store, a_mutbl, a_bounds),
        &ty::ty_trait(b_id, ref b_substs, b_store, b_mutbl, b_bounds))
       if a_id == b_id && a_mutbl == b_mutbl => {
+          debug!("Trying to match traits {:?} and {:?}", a, b);
           let substs = if_ok!(this.substs(a_id, a_substs, b_substs));
           let s = if_ok!(this.trait_stores(ty::terr_trait, a_store, b_store));
           let bounds = if_ok!(this.bounds(a_bounds, b_bounds));

src/librustdoc/lib.rs

@@ -53,7 +53,7 @@ pub mod test;
 pub static SCHEMA_VERSION: &'static str = "0.8.1";
 
 type Pass = (&'static str,                                      // name
-             extern fn(clean::Crate) -> plugins::PluginResult,  // fn
+             fn(clean::Crate) -> plugins::PluginResult,         // fn
              &'static str);                                     // description
 
 static PASSES: &'static [Pass] = &[

src/librustdoc/plugins.rs

@@ -15,7 +15,7 @@ use dl = std::unstable::dynamic_lib;
 
 pub type PluginJson = Option<(~str, json::Json)>;
 pub type PluginResult = (clean::Crate, PluginJson);
-pub type PluginCallback = extern fn (clean::Crate) -> PluginResult;
+pub type PluginCallback = fn (clean::Crate) -> PluginResult;
 
 /// Manages loading and running of plugins
 pub struct PluginManager {

src/libsyntax/parse/parser.rs

@@ -862,11 +862,12 @@ impl Parser {
 
         */
 
-        let opt_abis = if self.eat_keyword(keywords::Extern) {
-            self.parse_opt_abis()
-        } else { None };
+        let abis = if self.eat_keyword(keywords::Extern) {
+            self.parse_opt_abis().unwrap_or(AbiSet::C())
+        } else {
+            AbiSet::Rust()
+        };
 
-        let abis = opt_abis.unwrap_or(AbiSet::Rust());
         let purity = self.parse_unsafety();
         self.expect_keyword(keywords::Fn);
         let (decl, lifetimes) = self.parse_ty_fn_decl(true);

src/libtest/lib.rs

@@ -106,8 +106,8 @@ pub trait TDynBenchFn {
 // may need to come up with a more clever definition of test in order
 // to support isolation of tests into tasks.
 pub enum TestFn {
-    StaticTestFn(extern fn()),
-    StaticBenchFn(extern fn(&mut BenchHarness)),
+    StaticTestFn(fn()),
+    StaticBenchFn(fn(&mut BenchHarness)),
     StaticMetricFn(proc(&mut MetricMap)),
     DynTestFn(proc()),
     DynMetricFn(proc(&mut MetricMap)),

src/test/auxiliary/static-function-pointer-aux.rs

@@ -12,5 +12,5 @@
 
 pub fn f(x: int) -> int { -x }
 
-pub static F: extern fn(int) -> int = f;
-pub static mut MutF: extern fn(int) -> int = f;
+pub static F: fn(int) -> int = f;
+pub static mut MutF: fn(int) -> int = f;

src/test/compile-fail/block-coerce-no-2.rs

@@ -12,10 +12,10 @@
 // other tycons.
 
 fn main() {
-    fn f(f: extern fn(extern fn(extern fn()))) {
+    fn f(f: fn(fn(fn()))) {
     }
 
-    fn g(f: extern fn(||)) {
+    fn g(f: fn(||)) {
     }
 
     f(g);

src/test/compile-fail/borrowck-autoref-3261.rs

@@ -10,10 +10,10 @@
 
 enum Either<T, U> { Left(T), Right(U) }
 
-struct X(Either<(uint,uint),extern fn()>);
+struct X(Either<(uint,uint), fn()>);
 
 impl X {
-    pub fn with(&self, blk: |x: &Either<(uint,uint),extern fn()>|) {
+    pub fn with(&self, blk: |x: &Either<(uint,uint), fn()>|) {
         let X(ref e) = *self;
         blk(e)
     }

src/test/run-pass/const-vec-of-fns.rs

@@ -16,7 +16,7 @@
  */
 
 fn f() { }
-static bare_fns: &'static [extern fn()] = &[f, f];
+static bare_fns: &'static [fn()] = &[f, f];
 struct S<'a>('a ||);
 static closures: &'static [S<'static>] = &[S(f), S(f)];
 

src/test/run-pass/fn-abi.rs

@@ -0,0 +1,21 @@
+// Copyright 2014 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.
+
+// Ensure that declarations and types which use `extern fn` both have the same
+// ABI (#9309).
+
+extern {
+    fn printf();
+}
+
+pub fn main() {
+    // Will only type check if the type of _p and the decl of printf use the same ABI
+    let _p: extern unsafe fn() = printf;
+}