1 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
2 // file at the top-level directory of this distribution and at
3 // http://rust-lang.org/COPYRIGHT.
5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
8 // option. This file may not be copied, modified, or distributed
9 // except according to those terms.
13 // The job of the coherence phase of typechecking is to ensure that
14 // each trait has at most one implementation for each type. This is
15 // done by the orphan and overlap modules. Then we build up various
16 // mappings. That mapping code resides here.
18 use hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
19 use rustc::ty::{self, TyCtxt, TypeFoldable};
20 use rustc::ty::maps::Providers;
21 use rustc::dep_graph::DepNode;
24 use syntax_pos::DUMMY_SP;
28 mod inherent_impls_overlap;
33 fn check_impl<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, node_id: ast::NodeId) {
34 let impl_def_id = tcx.hir.local_def_id(node_id);
36 // If there are no traits, then this implementation must have a
39 if let Some(trait_ref) = tcx.impl_trait_ref(impl_def_id) {
40 debug!("(checking implementation) adding impl for trait '{:?}', item '{}'",
42 tcx.item_path_str(impl_def_id));
44 // Skip impls where one of the self type is an error type.
45 // This occurs with e.g. resolve failures (#30589).
46 if trait_ref.references_error() {
50 enforce_trait_manually_implementable(tcx, impl_def_id, trait_ref.def_id);
51 let trait_def = tcx.lookup_trait_def(trait_ref.def_id);
52 trait_def.record_local_impl(tcx, impl_def_id, trait_ref);
56 fn enforce_trait_manually_implementable(tcx: TyCtxt, impl_def_id: DefId, trait_def_id: DefId) {
57 let did = Some(trait_def_id);
58 let li = &tcx.lang_items;
60 // Disallow *all* explicit impls of `Sized` and `Unsize` for now.
61 if did == li.sized_trait() {
62 let span = tcx.span_of_impl(impl_def_id).unwrap();
63 struct_span_err!(tcx.sess,
66 "explicit impls for the `Sized` trait are not permitted")
67 .span_label(span, &format!("impl of 'Sized' not allowed"))
72 if did == li.unsize_trait() {
73 let span = tcx.span_of_impl(impl_def_id).unwrap();
77 "explicit impls for the `Unsize` trait are not permitted");
81 if tcx.sess.features.borrow().unboxed_closures {
82 // the feature gate allows all Fn traits
86 let trait_name = if did == li.fn_trait() {
88 } else if did == li.fn_mut_trait() {
90 } else if did == li.fn_once_trait() {
93 return; // everything OK
95 let mut err = struct_span_err!(tcx.sess,
96 tcx.span_of_impl(impl_def_id).unwrap(),
98 "manual implementations of `{}` are experimental",
101 "add `#![feature(unboxed_closures)]` to the crate attributes to enable");
105 pub fn provide(providers: &mut Providers) {
106 use self::builtin::coerce_unsized_info;
107 use self::inherent_impls::{crate_inherent_impls, inherent_impls};
108 use self::inherent_impls_overlap::crate_inherent_impls_overlap_check;
110 *providers = Providers {
112 crate_inherent_impls,
114 crate_inherent_impls_overlap_check,
120 fn coherent_trait<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
121 (_, def_id): (CrateNum, DefId)) {
122 tcx.populate_implementations_for_trait_if_necessary(def_id);
124 let impls = tcx.hir.trait_impls(def_id);
125 for &impl_id in impls {
126 check_impl(tcx, impl_id);
128 for &impl_id in impls {
129 overlap::check_impl(tcx, impl_id);
131 builtin::check_trait(tcx, def_id);
134 pub fn check_coherence<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
135 let _task = tcx.dep_graph.in_task(DepNode::Coherence);
136 for &trait_def_id in tcx.hir.krate().trait_impls.keys() {
137 ty::queries::coherent_trait::get(tcx, DUMMY_SP, (LOCAL_CRATE, trait_def_id));
140 unsafety::check(tcx);
142 overlap::check_default_impls(tcx);
144 // these queries are executed for side-effects (error reporting):
145 ty::queries::crate_inherent_impls::get(tcx, DUMMY_SP, LOCAL_CRATE);
146 ty::queries::crate_inherent_impls_overlap_check::get(tcx, DUMMY_SP, LOCAL_CRATE);