librustc: Fix bogus logic for static calls to unboxed closures in the

src/librustc/middle/expr_use_visitor.rs

@@ -130,16 +130,11 @@ impl OverloadedCallType {
 
     fn from_method_id(tcx: &ty::ctxt, method_id: ast::DefId)
                       -> OverloadedCallType {
-        let method_descriptor =
-            match tcx.impl_or_trait_items.borrow_mut().find(&method_id) {
-                Some(&ty::MethodTraitItem(ref method_descriptor)) => {
-                    (*method_descriptor).clone()
-                }
-                None => {
-                    tcx.sess.bug("overloaded call method wasn't in method \
-                                  map")
-                }
-            };
+        let method_descriptor = match ty::impl_or_trait_item(tcx, method_id) {
+            ty::MethodTraitItem(ref method_descriptor) => {
+                (*method_descriptor).clone()
+            }
+        };
         let impl_id = match method_descriptor.container {
             ty::TraitContainer(_) => {
                 tcx.sess.bug("statically resolved overloaded call method \
@@ -157,14 +152,27 @@ impl OverloadedCallType {
         OverloadedCallType::from_trait_id(tcx, trait_ref.def_id)
     }
 
+    fn from_unboxed_closure(tcx: &ty::ctxt, closure_did: ast::DefId)
+                            -> OverloadedCallType {
+        let trait_did =
+            tcx.unboxed_closures
+               .borrow()
+               .find(&closure_did)
+               .expect("OverloadedCallType::from_unboxed_closure: didn't \
+                        find closure id")
+               .kind
+               .trait_did(tcx);
+        OverloadedCallType::from_trait_id(tcx, trait_did)
+    }
+
     fn from_method_origin(tcx: &ty::ctxt, origin: &MethodOrigin)
                           -> OverloadedCallType {
         match *origin {
             MethodStatic(def_id) => {
                 OverloadedCallType::from_method_id(tcx, def_id)
             }
             MethodStaticUnboxedClosure(def_id) => {
-                OverloadedCallType::from_method_id(tcx, def_id)
+                OverloadedCallType::from_unboxed_closure(tcx, def_id)
             }
             MethodParam(ref method_param) => {
                 OverloadedCallType::from_trait_id(tcx, method_param.trait_id)

src/librustc/middle/ty.rs

@@ -19,7 +19,8 @@ use middle::def;
 use middle::dependency_format;
 use middle::freevars::CaptureModeMap;
 use middle::freevars;
-use middle::lang_items::{FnMutTraitLangItem, OpaqueStructLangItem};
+use middle::lang_items::{FnTraitLangItem, FnMutTraitLangItem};
+use middle::lang_items::{FnOnceTraitLangItem, OpaqueStructLangItem};
 use middle::lang_items::{TyDescStructLangItem, TyVisitorTraitLangItem};
 use middle::mem_categorization as mc;
 use middle::resolve;
@@ -1205,6 +1206,24 @@ pub enum UnboxedClosureKind {
     FnOnceUnboxedClosureKind,
 }
 
+impl UnboxedClosureKind {
+    pub fn trait_did(&self, cx: &ctxt) -> ast::DefId {
+        let result = match *self {
+            FnUnboxedClosureKind => cx.lang_items.require(FnTraitLangItem),
+            FnMutUnboxedClosureKind => {
+                cx.lang_items.require(FnMutTraitLangItem)
+            }
+            FnOnceUnboxedClosureKind => {
+                cx.lang_items.require(FnOnceTraitLangItem)
+            }
+        };
+        match result {
+            Ok(trait_did) => trait_did,
+            Err(err) => cx.sess.fatal(err.as_slice()),
+        }
+    }
+}
+
 pub fn mk_ctxt(s: Session,
                dm: resolve::DefMap,
                named_region_map: resolve_lifetime::NamedRegionMap,

src/test/run-pass/unboxed-closures-direct-sugary-call.rs

@@ -0,0 +1,17 @@
+// 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.
+
+#![feature(unboxed_closures, overloaded_calls)]
+
+fn main() {
+    let mut unboxed = |&mut:| {};
+    unboxed();
+}
+