mirror of
https://github.com/servo/servo.git
synced 2025-06-06 16:45:39 +00:00
a6d59d8714
For each derived DomObject impl, we also generate a dummy trait
ShouldNotImplDomObject that is implemented for all T: DomObject.
We then try to implement it for each field type except the first one.
If compilation succeed, this means that field type doesn't implement
DomObject itself otherwise it would break coherence rules.
error[E0119]: conflicting implementations of trait `dom::xmlhttprequest::_IMPL_DOMOBJECT_FOR_XMLHttpRequest::ShouldNotImplDomObject` for type `((), SomeFieldTypeThatShouldNotImplementDomObject)`:
--> /Users/nox/src/servo/components/script/dom/xmlhttprequest.rs:120:1
|
120 | #[dom_struct]
| ^^^^^^^^^^^^^
| |
| first implementation here
| conflicting implementation for `((), SomeFieldTypeThatShouldNotImplementDomObject)`
73 lines
2.7 KiB
Rust
73 lines
2.7 KiB
Rust
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
use rustc::hir::def_id::DefId;
|
|
use rustc::lint::{LateContext, LintContext};
|
|
use syntax::ast;
|
|
use syntax::codemap::{ExpnFormat, Span};
|
|
use syntax::ptr::P;
|
|
|
|
/// Matches a type with a provided string, and returns its type parameters if successful
|
|
pub fn match_ty_unwrap<'a>(ty: &'a ast::Ty, segments: &[&str]) -> Option<&'a [P<ast::Ty>]> {
|
|
match ty.node {
|
|
ast::TyKind::Path(_, ast::Path { segments: ref seg, .. }) => {
|
|
// So hir::Path isn't the full path, just the tokens that were provided.
|
|
// I could muck around with the maps and find the full path
|
|
// however the more efficient way is to simply reverse the iterators and zip them
|
|
// which will compare them in reverse until one of them runs out of segments
|
|
if seg.iter().rev().zip(segments.iter().rev()).all(|(a, b)| &*a.identifier.name.as_str() == *b) {
|
|
match seg.last() {
|
|
Some(&ast::PathSegment { parameters: Some(ref params), .. }) => {
|
|
match **params {
|
|
ast::PathParameters::AngleBracketed(ref a) => Some(&a.types),
|
|
|
|
// `Foo(A,B) -> C`
|
|
ast::PathParameters::Parenthesized(_) => None,
|
|
}
|
|
}
|
|
Some(&ast::PathSegment { parameters: None, .. }) => Some(&[]),
|
|
None => None,
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
},
|
|
_ => None
|
|
}
|
|
}
|
|
|
|
/// check if a DefId's path matches the given absolute type path
|
|
/// usage e.g. with
|
|
/// `match_def_path(cx, id, &["core", "option", "Option"])`
|
|
pub fn match_def_path(cx: &LateContext, def_id: DefId, path: &[&str]) -> bool {
|
|
let krate = &cx.tcx.crate_name(def_id.krate);
|
|
if krate != &path[0] {
|
|
return false;
|
|
}
|
|
|
|
let path = &path[1..];
|
|
let other = cx.tcx.def_path(def_id).data;
|
|
|
|
if other.len() != path.len() {
|
|
return false;
|
|
}
|
|
|
|
other.into_iter()
|
|
.map(|e| e.data)
|
|
.zip(path)
|
|
.all(|(nm, p)| &*nm.as_interned_str() == *p)
|
|
}
|
|
|
|
pub fn in_derive_expn(cx: &LateContext, span: Span) -> bool {
|
|
cx.sess().codemap().with_expn_info(span.expn_id,
|
|
|info| {
|
|
if let Some(i) = info {
|
|
if let ExpnFormat::MacroAttribute(n) = i.callee.format {
|
|
if n.as_str().contains("derive") {
|
|
true
|
|
} else { false }
|
|
} else { false }
|
|
} else { false }
|
|
})
|
|
}
|