]> git.proxmox.com Git - rustc.git/blame - src/librustc/middle/traits/structural_impls.rs
Imported Upstream version 1.8.0+dfsg1
[rustc.git] / src / librustc / middle / traits / structural_impls.rs
CommitLineData
e9174d1e
SL
1// Copyright 2012-2015 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.
4//
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.
10
11use middle::traits;
12use middle::traits::project::Normalized;
9cc50fc6 13use middle::ty::fold::{TypeFoldable, TypeFolder, TypeVisitor};
e9174d1e
SL
14
15use std::fmt;
16
17// structural impls for the structs in middle::traits
18
19impl<'tcx, T: fmt::Debug> fmt::Debug for Normalized<'tcx, T> {
20 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
21 write!(f, "Normalized({:?},{:?})",
22 self.value,
23 self.obligations)
24 }
25}
26
27impl<'tcx> fmt::Debug for traits::RegionObligation<'tcx> {
28 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
29 write!(f, "RegionObligation(sub_region={:?}, sup_type={:?})",
30 self.sub_region,
31 self.sup_type)
32 }
33}
34impl<'tcx, O: fmt::Debug> fmt::Debug for traits::Obligation<'tcx, O> {
35 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
36 write!(f, "Obligation(predicate={:?},depth={})",
37 self.predicate,
38 self.recursion_depth)
39 }
40}
41
42impl<'tcx, N: fmt::Debug> fmt::Debug for traits::Vtable<'tcx, N> {
43 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
44 match *self {
45 super::VtableImpl(ref v) =>
46 write!(f, "{:?}", v),
47
48 super::VtableDefaultImpl(ref t) =>
49 write!(f, "{:?}", t),
50
51 super::VtableClosure(ref d) =>
52 write!(f, "{:?}", d),
53
54 super::VtableFnPointer(ref d) =>
55 write!(f, "VtableFnPointer({:?})", d),
56
57 super::VtableObject(ref d) =>
58 write!(f, "{:?}", d),
59
60 super::VtableParam(ref n) =>
61 write!(f, "VtableParam({:?})", n),
62
63 super::VtableBuiltin(ref d) =>
64 write!(f, "{:?}", d)
65 }
66 }
67}
68
69impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableImplData<'tcx, N> {
70 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
71 write!(f, "VtableImpl(impl_def_id={:?}, substs={:?}, nested={:?})",
72 self.impl_def_id,
73 self.substs,
74 self.nested)
75 }
76}
77
78impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableClosureData<'tcx, N> {
79 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
80 write!(f, "VtableClosure(closure_def_id={:?}, substs={:?}, nested={:?})",
81 self.closure_def_id,
82 self.substs,
83 self.nested)
84 }
85}
86
87impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableBuiltinData<N> {
88 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
89 write!(f, "VtableBuiltin(nested={:?})", self.nested)
90 }
91}
92
93impl<'tcx, N: fmt::Debug> fmt::Debug for traits::VtableDefaultImplData<N> {
94 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
95 write!(f, "VtableDefaultImplData(trait_def_id={:?}, nested={:?})",
96 self.trait_def_id,
97 self.nested)
98 }
99}
100
101impl<'tcx> fmt::Debug for traits::VtableObjectData<'tcx> {
102 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
103 write!(f, "VtableObject(upcast={:?}, vtable_base={})",
104 self.upcast_trait_ref,
105 self.vtable_base)
106 }
107}
108
109impl<'tcx> fmt::Debug for traits::FulfillmentError<'tcx> {
110 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
111 write!(f, "FulfillmentError({:?},{:?})",
112 self.obligation,
113 self.code)
114 }
115}
116
117impl<'tcx> fmt::Debug for traits::FulfillmentErrorCode<'tcx> {
118 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
119 match *self {
120 super::CodeSelectionError(ref e) => write!(f, "{:?}", e),
121 super::CodeProjectionError(ref e) => write!(f, "{:?}", e),
122 super::CodeAmbiguity => write!(f, "Ambiguity")
123 }
124 }
125}
126
127impl<'tcx> fmt::Debug for traits::MismatchedProjectionTypes<'tcx> {
128 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
129 write!(f, "MismatchedProjectionTypes({:?})", self.err)
130 }
131}
132
e9174d1e
SL
133impl<'tcx, O: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::Obligation<'tcx, O>
134{
9cc50fc6 135 fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
e9174d1e
SL
136 traits::Obligation {
137 cause: self.cause.clone(),
138 recursion_depth: self.recursion_depth,
139 predicate: self.predicate.fold_with(folder),
140 }
141 }
9cc50fc6
SL
142
143 fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
144 self.predicate.visit_with(visitor)
145 }
e9174d1e
SL
146}
147
148impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableImplData<'tcx, N> {
9cc50fc6 149 fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
e9174d1e
SL
150 traits::VtableImplData {
151 impl_def_id: self.impl_def_id,
152 substs: self.substs.fold_with(folder),
153 nested: self.nested.fold_with(folder),
154 }
155 }
9cc50fc6
SL
156
157 fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
158 self.substs.visit_with(visitor) || self.nested.visit_with(visitor)
159 }
e9174d1e
SL
160}
161
162impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableClosureData<'tcx, N> {
9cc50fc6 163 fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
e9174d1e
SL
164 traits::VtableClosureData {
165 closure_def_id: self.closure_def_id,
166 substs: self.substs.fold_with(folder),
167 nested: self.nested.fold_with(folder),
168 }
169 }
9cc50fc6
SL
170
171 fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
172 self.substs.visit_with(visitor) || self.nested.visit_with(visitor)
173 }
e9174d1e
SL
174}
175
176impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableDefaultImplData<N> {
9cc50fc6 177 fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
e9174d1e
SL
178 traits::VtableDefaultImplData {
179 trait_def_id: self.trait_def_id,
180 nested: self.nested.fold_with(folder),
181 }
182 }
9cc50fc6
SL
183
184 fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
185 self.nested.visit_with(visitor)
186 }
e9174d1e
SL
187}
188
189impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::VtableBuiltinData<N> {
9cc50fc6 190 fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
e9174d1e
SL
191 traits::VtableBuiltinData {
192 nested: self.nested.fold_with(folder),
193 }
194 }
9cc50fc6
SL
195
196 fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
197 self.nested.visit_with(visitor)
198 }
e9174d1e
SL
199}
200
201impl<'tcx> TypeFoldable<'tcx> for traits::VtableObjectData<'tcx> {
9cc50fc6 202 fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
e9174d1e
SL
203 traits::VtableObjectData {
204 upcast_trait_ref: self.upcast_trait_ref.fold_with(folder),
205 vtable_base: self.vtable_base
206 }
207 }
9cc50fc6
SL
208
209 fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
210 self.upcast_trait_ref.visit_with(visitor)
211 }
e9174d1e
SL
212}
213
214impl<'tcx, N: TypeFoldable<'tcx>> TypeFoldable<'tcx> for traits::Vtable<'tcx, N> {
9cc50fc6 215 fn super_fold_with<F:TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
e9174d1e
SL
216 match *self {
217 traits::VtableImpl(ref v) => traits::VtableImpl(v.fold_with(folder)),
218 traits::VtableDefaultImpl(ref t) => traits::VtableDefaultImpl(t.fold_with(folder)),
219 traits::VtableClosure(ref d) => {
220 traits::VtableClosure(d.fold_with(folder))
221 }
222 traits::VtableFnPointer(ref d) => {
223 traits::VtableFnPointer(d.fold_with(folder))
224 }
225 traits::VtableParam(ref n) => traits::VtableParam(n.fold_with(folder)),
226 traits::VtableBuiltin(ref d) => traits::VtableBuiltin(d.fold_with(folder)),
227 traits::VtableObject(ref d) => traits::VtableObject(d.fold_with(folder)),
228 }
229 }
9cc50fc6
SL
230
231 fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
232 match *self {
233 traits::VtableImpl(ref v) => v.visit_with(visitor),
234 traits::VtableDefaultImpl(ref t) => t.visit_with(visitor),
235 traits::VtableClosure(ref d) => d.visit_with(visitor),
236 traits::VtableFnPointer(ref d) => d.visit_with(visitor),
237 traits::VtableParam(ref n) => n.visit_with(visitor),
238 traits::VtableBuiltin(ref d) => d.visit_with(visitor),
239 traits::VtableObject(ref d) => d.visit_with(visitor),
240 }
241 }
e9174d1e
SL
242}
243
244impl<'tcx, T: TypeFoldable<'tcx>> TypeFoldable<'tcx> for Normalized<'tcx, T> {
9cc50fc6 245 fn super_fold_with<F: TypeFolder<'tcx>>(&self, folder: &mut F) -> Self {
e9174d1e
SL
246 Normalized {
247 value: self.value.fold_with(folder),
248 obligations: self.obligations.fold_with(folder),
249 }
250 }
9cc50fc6
SL
251
252 fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
253 self.value.visit_with(visitor) || self.obligations.visit_with(visitor)
254 }
e9174d1e 255}