Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-05 21:50:18 +01:00
Code Issues Projects Releases Packages Wiki Activity

Auto merge of #24319 - servo:webidl-lint, r=jdm

Browse source 
Remove redundant webidl_must_inherit compiler plugin lint

At first I was considering moving it to a procedural macro (source-level information should be sufficient), and started by trying to reproduce the error case by changing `htmldivelement.rs` to use `Element` instead of `HTMLElement` as the first field.

The output was:

```rust
error[E0308]: mismatched types
   --> /home/simon/servo2/target/debug/build/script-4caa244faca7d10f/out/Bindings/HTMLDivElementBinding.rs:665:31
    |
665 |         let _: &HTMLElement = self.as_parent();
    |                               ^^^^^^^^^^^^^^^^ expected struct `dom::htmlelement::HTMLElement`, found struct `dom::element::Element`
    |
    = note: expected type `&dom::htmlelement::HTMLElement`
               found type `&dom::element::Element`
```

This line number is inside a generated method called `__assert_parent_type`. As far as I can tell, any case where this lint would error is already caught by such methods. The lint is therefore redundant and can safely be removed.

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/24319)
<!-- Reviewable:end -->
This commit is contained in:
bors-servo 2019-09-30 14:47:18 -04:00 • committed by GitHub
commit ebd59ef4f4
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
8 changed files with 338 additions and 606 deletions
Download patch file Download diff file Expand all files Collapse all files

12
Cargo.lock generated
View file

@ -3992,9 +3992,6 @@ dependencies = [
[[package]]
name = "script_plugins"
version = "0.0.1"
dependencies = [
"weedle 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "script_plugins_tests"
@ -5673,14 +5670,6 @@ dependencies = [
"serde 1.0.88 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "weedle"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
dependencies = [
"nom 4.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
]
[[package]]
name = "which"
version = "3.0.0"
@ -6316,7 +6305,6 @@ dependencies = [
"checksum webrender_build 0.0.1 (git+https://github.com/servo/webrender)" = "<none>"
"checksum webxr 0.0.1 (git+https://github.com/servo/webxr)" = "<none>"
"checksum webxr-api 0.0.1 (git+https://github.com/servo/webxr)" = "<none>"
"checksum weedle 0.10.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3bb43f70885151e629e2a19ce9e50bd730fd436cfd4b666894c9ce4de9141164"
"checksum which 3.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "240a31163872f7e8e49f35b42b58485e35355b07eb009d9f3686733541339a69"
"checksum winapi 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "f10e386af2b13e47c89e7236a7a14a086791a2b88ebad6df9bf42040195cf770"
"checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"

1
components/dom_struct/lib.rs
View file

@ -19,7 +19,6 @@ pub fn dom_struct(args: TokenStream, input: TokenStream) -> TokenStream {
#[derive(DenyPublicFields, DomObject, JSTraceable, MallocSizeOf)]
#[must_root]
#[repr(C)]
#[webidl]
};
// Work around https://github.com/rust-lang/rust/issues/46489

3
components/script/Cargo.toml
View file

@ -16,8 +16,7 @@ path = "lib.rs"
debugmozjs = ['js/debugmozjs']
profilemozjs = ['js/profilemozjs']
unrooted_must_root_lint = ["script_plugins/unrooted_must_root_lint"]
webidl_lint = ["script_plugins/webidl_lint"]
default = ["unrooted_must_root_lint", "webidl_lint"]
default = ["unrooted_must_root_lint"]
webgl_backtrace = ["backtrace", "canvas_traits/webgl_backtrace"]
js_backtrace = ["backtrace"]
uwp = ["js/uwp"]

4
components/script_plugins/Cargo.toml
View file

@ -11,7 +11,3 @@ plugin = true
[features]
unrooted_must_root_lint = []
webidl_lint = []
[dependencies]
weedle = "0.10"

364
components/script_plugins/lib.rs
View file

@ -17,47 +17,358 @@
#![feature(plugin)]
#![feature(plugin_registrar)]
#![feature(rustc_private)]
#![cfg(feature = "unrooted_must_root_lint")]
#[cfg(feature = "unrooted_must_root_lint")]
#[macro_use]
extern crate rustc;
extern crate rustc_driver;
extern crate syntax;
extern crate weedle;
use rustc::hir::def_id::DefId;
use rustc::hir::intravisit as visit;
use rustc::hir::{self, ExprKind, HirId};
use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass};
use rustc::ty;
use rustc_driver::plugin::Registry;
use syntax::feature_gate::AttributeType::Whitelisted;
use syntax::source_map;
use syntax::source_map::{ExpnKind, MacroKind, Span};
use syntax::symbol::sym;
use syntax::symbol::Symbol;
#[cfg(feature = "unrooted_must_root_lint")]
mod unrooted_must_root;
#[cfg(feature = "webidl_lint")]
mod webidl_must_inherit;
/// Utilities for writing plugins
#[cfg(feature = "unrooted_must_root_lint")]
mod utils;
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
let symbols = crate::Symbols::new();
#[cfg(feature = "unrooted_must_root_lint")]
reg.register_late_lint_pass(Box::new(unrooted_must_root::UnrootedPass::new(
symbols.clone(),
)));
#[cfg(feature = "webidl_lint")]
reg.register_late_lint_pass(Box::new(webidl_must_inherit::WebIdlPass::new(
symbols.clone(),
)));
let symbols = Symbols::new();
reg.register_attribute(symbols.allow_unrooted_interior, Whitelisted);
reg.register_attribute(symbols.allow_unrooted_in_rc, Whitelisted);
reg.register_attribute(symbols.must_root, Whitelisted);
reg.register_attribute(symbols.webidl, Whitelisted);
reg.register_late_lint_pass(Box::new(UnrootedPass::new(symbols)));
}
declare_lint!(
UNROOTED_MUST_ROOT,
Deny,
"Warn and report usage of unrooted jsmanaged objects"
);
/// Lint for ensuring safe usage of unrooted pointers
///
/// This lint (disable with `-A unrooted-must-root`/`#[allow(unrooted_must_root)]`) ensures that `#[must_root]`
/// values are used correctly.
///
/// "Incorrect" usage includes:
///
/// - Not being used in a struct/enum field which is not `#[must_root]` itself
/// - Not being used as an argument to a function (Except onces named `new` and `new_inherited`)
/// - Not being bound locally in a `let` statement, assignment, `for` loop, or `match` statement.
///
/// This helps catch most situations where pointers like `JS<T>` are used in a way that they can be invalidated by a
/// GC pass.
///
/// Structs which have their own mechanism of rooting their unrooted contents (e.g. `ScriptThread`)
/// can be marked as `#[allow(unrooted_must_root)]`. Smart pointers which root their interior type
/// can be marked as `#[allow_unrooted_interior]`
pub(crate) struct UnrootedPass {
symbols: Symbols,
}
impl UnrootedPass {
pub fn new(symbols: Symbols) -> UnrootedPass {
UnrootedPass { symbols }
}
}
/// Checks if a type is unrooted or contains any owned unrooted types
fn is_unrooted_ty(sym: &Symbols, cx: &LateContext, ty: &ty::TyS, in_new_function: bool) -> bool {
let mut ret = false;
ty.maybe_walk(|t| {
match t.kind {
ty::Adt(did, substs) => {
if cx.tcx.has_attr(did.did, sym.must_root) {
ret = true;
false
} else if cx.tcx.has_attr(did.did, sym.allow_unrooted_interior) {
false
} else if match_def_path(cx, did.did, &[sym.alloc, sym.rc, sym.Rc]) {
// Rc<Promise> is okay
let inner = substs.type_at(0);
if let ty::Adt(did, _) = inner.kind {
if cx.tcx.has_attr(did.did, sym.allow_unrooted_in_rc) {
false
} else {
true
}
} else {
true
}
} else if match_def_path(cx, did.did, &[sym::core, sym.cell, sym.Ref]) ||
match_def_path(cx, did.did, &[sym::core, sym.cell, sym.RefMut]) ||
match_def_path(cx, did.did, &[sym::core, sym.slice, sym.Iter]) ||
match_def_path(cx, did.did, &[sym::core, sym.slice, sym.IterMut]) ||
match_def_path(
cx,
did.did,
&[sym::std, sym.collections, sym.hash, sym.map, sym.Entry],
) ||
match_def_path(
cx,
did.did,
&[
sym::std,
sym.collections,
sym.hash,
sym.map,
sym.OccupiedEntry,
],
) ||
match_def_path(
cx,
did.did,
&[
sym::std,
sym.collections,
sym.hash,
sym.map,
sym.VacantEntry,
],
) ||
match_def_path(
cx,
did.did,
&[sym::std, sym.collections, sym.hash, sym.map, sym.Iter],
) ||
match_def_path(
cx,
did.did,
&[sym::std, sym.collections, sym.hash, sym.set, sym.Iter],
)
{
// Structures which are semantically similar to an &ptr.
false
} else if did.is_box() && in_new_function {
// box in new() is okay
false
} else {
true
}
},
ty::Ref(..) => false, // don't recurse down &ptrs
ty::RawPtr(..) => false, // don't recurse down *ptrs
ty::FnDef(..) | ty::FnPtr(_) => false,
_ => true,
}
});
ret
}
impl LintPass for UnrootedPass {
fn name(&self) -> &'static str {
"ServoUnrootedPass"
}
fn get_lints(&self) -> LintArray {
lint_array!(UNROOTED_MUST_ROOT)
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnrootedPass {
/// All structs containing #[must_root] types must be #[must_root] themselves
fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) {
if item
.attrs
.iter()
.any(|a| a.check_name(self.symbols.must_root))
{
return;
}
if let hir::ItemKind::Struct(def, ..) = &item.kind {
for ref field in def.fields() {
let def_id = cx.tcx.hir().local_def_id(field.hir_id);
if is_unrooted_ty(&self.symbols, cx, cx.tcx.type_of(def_id), false) {
cx.span_lint(UNROOTED_MUST_ROOT, field.span,
"Type must be rooted, use #[must_root] on the struct definition to propagate")
}
}
}
}
/// All enums containing #[must_root] types must be #[must_root] themselves
fn check_variant(&mut self, cx: &LateContext, var: &hir::Variant) {
let ref map = cx.tcx.hir();
if map
.expect_item(map.get_parent_item(var.id))
.attrs
.iter()
.all(|a| !a.check_name(self.symbols.must_root))
{
match var.data {
hir::VariantData::Tuple(ref fields, ..) => {
for ref field in fields {
let def_id = cx.tcx.hir().local_def_id(field.hir_id);
if is_unrooted_ty(&self.symbols, cx, cx.tcx.type_of(def_id), false) {
cx.span_lint(
UNROOTED_MUST_ROOT,
field.ty.span,
"Type must be rooted, use #[must_root] on \
the enum definition to propagate",
)
}
}
},
_ => (), // Struct variants already caught by check_struct_def
}
}
}
/// Function arguments that are #[must_root] types are not allowed
fn check_fn(
&mut self,
cx: &LateContext<'a, 'tcx>,
kind: visit::FnKind<'tcx>,
decl: &'tcx hir::FnDecl,
body: &'tcx hir::Body,
span: source_map::Span,
id: HirId,
) {
let in_new_function = match kind {
visit::FnKind::ItemFn(n, _, _, _, _) | visit::FnKind::Method(n, _, _, _) => {
&*n.as_str() == "new" || n.as_str().starts_with("new_")
},
visit::FnKind::Closure(_) => return,
};
if !in_derive_expn(span) {
let def_id = cx.tcx.hir().local_def_id(id);
let sig = cx.tcx.type_of(def_id).fn_sig(cx.tcx);
for (arg, ty) in decl.inputs.iter().zip(sig.inputs().skip_binder().iter()) {
if is_unrooted_ty(&self.symbols, cx, ty, false) {
cx.span_lint(UNROOTED_MUST_ROOT, arg.span, "Type must be rooted")
}
}
if !in_new_function {
if is_unrooted_ty(&self.symbols, cx, sig.output().skip_binder(), false) {
cx.span_lint(
UNROOTED_MUST_ROOT,
decl.output.span(),
"Type must be rooted",
)
}
}
}
let mut visitor = FnDefVisitor {
symbols: &self.symbols,
cx: cx,
in_new_function: in_new_function,
};
visit::walk_expr(&mut visitor, &body.value);
}
}
struct FnDefVisitor<'a, 'b: 'a, 'tcx: 'a + 'b> {
symbols: &'a Symbols,
cx: &'a LateContext<'b, 'tcx>,
in_new_function: bool,
}
impl<'a, 'b, 'tcx> visit::Visitor<'tcx> for FnDefVisitor<'a, 'b, 'tcx> {
fn visit_expr(&mut self, expr: &'tcx hir::Expr) {
let cx = self.cx;
let require_rooted = |cx: &LateContext, in_new_function: bool, subexpr: &hir::Expr| {
let ty = cx.tables.expr_ty(&subexpr);
if is_unrooted_ty(&self.symbols, cx, ty, in_new_function) {
cx.span_lint(
UNROOTED_MUST_ROOT,
subexpr.span,
&format!("Expression of type {:?} must be rooted", ty),
)
}
};
match expr.kind {
// Trait casts from #[must_root] types are not allowed
ExprKind::Cast(ref subexpr, _) => require_rooted(cx, self.in_new_function, &*subexpr),
// This catches assignments... the main point of this would be to catch mutable
// references to `JS<T>`.
// FIXME: Enable this? Triggers on certain kinds of uses of DomRefCell.
// hir::ExprAssign(_, ref rhs) => require_rooted(cx, self.in_new_function, &*rhs),
// This catches calls; basically, this enforces the constraint that only constructors
// can call other constructors.
// FIXME: Enable this? Currently triggers with constructs involving DomRefCell, and
// constructs like Vec<JS<T>> and RootedVec<JS<T>>.
// hir::ExprCall(..) if !self.in_new_function => {
// require_rooted(cx, self.in_new_function, expr);
// }
_ => {
// TODO(pcwalton): Check generics with a whitelist of allowed generics.
},
}
visit::walk_expr(self, expr);
}
fn visit_pat(&mut self, pat: &'tcx hir::Pat) {
let cx = self.cx;
// We want to detect pattern bindings that move a value onto the stack.
// When "default binding modes" https://github.com/rust-lang/rust/issues/42640
// are implemented, the `Unannotated` case could cause false-positives.
// These should be fixable by adding an explicit `ref`.
match pat.kind {
hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, ..) |
hir::PatKind::Binding(hir::BindingAnnotation::Mutable, ..) => {
let ty = cx.tables.pat_ty(pat);
if is_unrooted_ty(&self.symbols, cx, ty, self.in_new_function) {
cx.span_lint(
UNROOTED_MUST_ROOT,
pat.span,
&format!("Expression of type {:?} must be rooted", ty),
)
}
},
_ => {},
}
visit::walk_pat(self, pat);
}
fn visit_ty(&mut self, _: &'tcx hir::Ty) {}
fn nested_visit_map<'this>(&'this mut self) -> hir::intravisit::NestedVisitorMap<'this, 'tcx> {
hir::intravisit::NestedVisitorMap::OnlyBodies(&self.cx.tcx.hir())
}
}
/// check if a DefId's path matches the given absolute type path
/// usage e.g. with
/// `match_def_path(cx, id, &["core", "option", "Option"])`
fn match_def_path(cx: &LateContext, def_id: DefId, path: &[Symbol]) -> 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()
.zip(path)
.all(|(e, p)| e.data.as_interned_str().as_symbol() == *p)
}
fn in_derive_expn(span: Span) -> bool {
if let ExpnKind::Macro(MacroKind::Attr, n) = span.ctxt().outer_expn_data().kind {
n.as_str().contains("derive")
} else {
false
}
}
macro_rules! symbols {
@ -82,7 +393,6 @@ symbols! {
allow_unrooted_interior
allow_unrooted_in_rc
must_root
webidl
alloc
rc
Rc

312
components/script_plugins/unrooted_must_root.rs
View file

@ -1,312 +0,0 @@
/* 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 https://mozilla.org/MPL/2.0/. */
use crate::utils::{in_derive_expn, match_def_path};
use rustc::hir::intravisit as visit;
use rustc::hir::{self, ExprKind, HirId};
use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass};
use rustc::ty;
use syntax::source_map;
use syntax::symbol::sym;
declare_lint!(
UNROOTED_MUST_ROOT,
Deny,
"Warn and report usage of unrooted jsmanaged objects"
);
/// Lint for ensuring safe usage of unrooted pointers
///
/// This lint (disable with `-A unrooted-must-root`/`#[allow(unrooted_must_root)]`) ensures that `#[must_root]`
/// values are used correctly.
///
/// "Incorrect" usage includes:
///
/// - Not being used in a struct/enum field which is not `#[must_root]` itself
/// - Not being used as an argument to a function (Except onces named `new` and `new_inherited`)
/// - Not being bound locally in a `let` statement, assignment, `for` loop, or `match` statement.
///
/// This helps catch most situations where pointers like `JS<T>` are used in a way that they can be invalidated by a
/// GC pass.
///
/// Structs which have their own mechanism of rooting their unrooted contents (e.g. `ScriptThread`)
/// can be marked as `#[allow(unrooted_must_root)]`. Smart pointers which root their interior type
/// can be marked as `#[allow_unrooted_interior]`
pub(crate) struct UnrootedPass {
symbols: crate::Symbols,
}
impl UnrootedPass {
pub fn new(symbols: crate::Symbols) -> UnrootedPass {
UnrootedPass { symbols }
}
}
/// Checks if a type is unrooted or contains any owned unrooted types
fn is_unrooted_ty(
sym: &crate::Symbols,
cx: &LateContext,
ty: &ty::TyS,
in_new_function: bool,
) -> bool {
let mut ret = false;
ty.maybe_walk(|t| {
match t.kind {
ty::Adt(did, substs) => {
if cx.tcx.has_attr(did.did, sym.must_root) {
ret = true;
false
} else if cx.tcx.has_attr(did.did, sym.allow_unrooted_interior) {
false
} else if match_def_path(cx, did.did, &[sym.alloc, sym.rc, sym.Rc]) {
// Rc<Promise> is okay
let inner = substs.type_at(0);
if let ty::Adt(did, _) = inner.kind {
if cx.tcx.has_attr(did.did, sym.allow_unrooted_in_rc) {
false
} else {
true
}
} else {
true
}
} else if match_def_path(cx, did.did, &[sym::core, sym.cell, sym.Ref]) ||
match_def_path(cx, did.did, &[sym::core, sym.cell, sym.RefMut]) ||
match_def_path(cx, did.did, &[sym::core, sym.slice, sym.Iter]) ||
match_def_path(cx, did.did, &[sym::core, sym.slice, sym.IterMut]) ||
match_def_path(
cx,
did.did,
&[sym::std, sym.collections, sym.hash, sym.map, sym.Entry],
) ||
match_def_path(
cx,
did.did,
&[
sym::std,
sym.collections,
sym.hash,
sym.map,
sym.OccupiedEntry,
],
) ||
match_def_path(
cx,
did.did,
&[
sym::std,
sym.collections,
sym.hash,
sym.map,
sym.VacantEntry,
],
) ||
match_def_path(
cx,
did.did,
&[sym::std, sym.collections, sym.hash, sym.map, sym.Iter],
) ||
match_def_path(
cx,
did.did,
&[sym::std, sym.collections, sym.hash, sym.set, sym.Iter],
)
{
// Structures which are semantically similar to an &ptr.
false
} else if did.is_box() && in_new_function {
// box in new() is okay
false
} else {
true
}
},
ty::Ref(..) => false, // don't recurse down &ptrs
ty::RawPtr(..) => false, // don't recurse down *ptrs
ty::FnDef(..) | ty::FnPtr(_) => false,
_ => true,
}
});
ret
}
impl LintPass for UnrootedPass {
fn name(&self) -> &'static str {
"ServoUnrootedPass"
}
fn get_lints(&self) -> LintArray {
lint_array!(UNROOTED_MUST_ROOT)
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnrootedPass {
/// All structs containing #[must_root] types must be #[must_root] themselves
fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) {
if item
.attrs
.iter()
.any(|a| a.check_name(self.symbols.must_root))
{
return;
}
if let hir::ItemKind::Struct(def, ..) = &item.kind {
for ref field in def.fields() {
let def_id = cx.tcx.hir().local_def_id(field.hir_id);
if is_unrooted_ty(&self.symbols, cx, cx.tcx.type_of(def_id), false) {
cx.span_lint(UNROOTED_MUST_ROOT, field.span,
"Type must be rooted, use #[must_root] on the struct definition to propagate")
}
}
}
}
/// All enums containing #[must_root] types must be #[must_root] themselves
fn check_variant(&mut self, cx: &LateContext, var: &hir::Variant) {
let ref map = cx.tcx.hir();
if map
.expect_item(map.get_parent_item(var.id))
.attrs
.iter()
.all(|a| !a.check_name(self.symbols.must_root))
{
match var.data {
hir::VariantData::Tuple(ref fields, ..) => {
for ref field in fields {
let def_id = cx.tcx.hir().local_def_id(field.hir_id);
if is_unrooted_ty(&self.symbols, cx, cx.tcx.type_of(def_id), false) {
cx.span_lint(
UNROOTED_MUST_ROOT,
field.ty.span,
"Type must be rooted, use #[must_root] on \
the enum definition to propagate",
)
}
}
},
_ => (), // Struct variants already caught by check_struct_def
}
}
}
/// Function arguments that are #[must_root] types are not allowed
fn check_fn(
&mut self,
cx: &LateContext<'a, 'tcx>,
kind: visit::FnKind<'tcx>,
decl: &'tcx hir::FnDecl,
body: &'tcx hir::Body,
span: source_map::Span,
id: HirId,
) {
let in_new_function = match kind {
visit::FnKind::ItemFn(n, _, _, _, _) | visit::FnKind::Method(n, _, _, _) => {
&*n.as_str() == "new" || n.as_str().starts_with("new_")
},
visit::FnKind::Closure(_) => return,
};
if !in_derive_expn(span) {
let def_id = cx.tcx.hir().local_def_id(id);
let sig = cx.tcx.type_of(def_id).fn_sig(cx.tcx);
for (arg, ty) in decl.inputs.iter().zip(sig.inputs().skip_binder().iter()) {
if is_unrooted_ty(&self.symbols, cx, ty, false) {
cx.span_lint(UNROOTED_MUST_ROOT, arg.span, "Type must be rooted")
}
}
if !in_new_function {
if is_unrooted_ty(&self.symbols, cx, sig.output().skip_binder(), false) {
cx.span_lint(
UNROOTED_MUST_ROOT,
decl.output.span(),
"Type must be rooted",
)
}
}
}
let mut visitor = FnDefVisitor {
symbols: &self.symbols,
cx: cx,
in_new_function: in_new_function,
};
visit::walk_expr(&mut visitor, &body.value);
}
}
struct FnDefVisitor<'a, 'b: 'a, 'tcx: 'a + 'b> {
symbols: &'a crate::Symbols,
cx: &'a LateContext<'b, 'tcx>,
in_new_function: bool,
}
impl<'a, 'b, 'tcx> visit::Visitor<'tcx> for FnDefVisitor<'a, 'b, 'tcx> {
fn visit_expr(&mut self, expr: &'tcx hir::Expr) {
let cx = self.cx;
let require_rooted = |cx: &LateContext, in_new_function: bool, subexpr: &hir::Expr| {
let ty = cx.tables.expr_ty(&subexpr);
if is_unrooted_ty(&self.symbols, cx, ty, in_new_function) {
cx.span_lint(
UNROOTED_MUST_ROOT,
subexpr.span,
&format!("Expression of type {:?} must be rooted", ty),
)
}
};
match expr.kind {
// Trait casts from #[must_root] types are not allowed
ExprKind::Cast(ref subexpr, _) => require_rooted(cx, self.in_new_function, &*subexpr),
// This catches assignments... the main point of this would be to catch mutable
// references to `JS<T>`.
// FIXME: Enable this? Triggers on certain kinds of uses of DomRefCell.
// hir::ExprAssign(_, ref rhs) => require_rooted(cx, self.in_new_function, &*rhs),
// This catches calls; basically, this enforces the constraint that only constructors
// can call other constructors.
// FIXME: Enable this? Currently triggers with constructs involving DomRefCell, and
// constructs like Vec<JS<T>> and RootedVec<JS<T>>.
// hir::ExprCall(..) if !self.in_new_function => {
// require_rooted(cx, self.in_new_function, expr);
// }
_ => {
// TODO(pcwalton): Check generics with a whitelist of allowed generics.
},
}
visit::walk_expr(self, expr);
}
fn visit_pat(&mut self, pat: &'tcx hir::Pat) {
let cx = self.cx;
// We want to detect pattern bindings that move a value onto the stack.
// When "default binding modes" https://github.com/rust-lang/rust/issues/42640
// are implemented, the `Unannotated` case could cause false-positives.
// These should be fixable by adding an explicit `ref`.
match pat.kind {
hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, ..) |
hir::PatKind::Binding(hir::BindingAnnotation::Mutable, ..) => {
let ty = cx.tables.pat_ty(pat);
if is_unrooted_ty(&self.symbols, cx, ty, self.in_new_function) {
cx.span_lint(
UNROOTED_MUST_ROOT,
pat.span,
&format!("Expression of type {:?} must be rooted", ty),
)
}
},
_ => {},
}
visit::walk_pat(self, pat);
}
fn visit_ty(&mut self, _: &'tcx hir::Ty) {}
fn nested_visit_map<'this>(&'this mut self) -> hir::intravisit::NestedVisitorMap<'this, 'tcx> {
hir::intravisit::NestedVisitorMap::OnlyBodies(&self.cx.tcx.hir())
}
}

38
components/script_plugins/utils.rs
View file

@ -1,38 +0,0 @@
/* 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 https://mozilla.org/MPL/2.0/. */
use rustc::hir::def_id::DefId;
use rustc::lint::LateContext;
use syntax::source_map::{ExpnKind, MacroKind, Span};
use syntax::symbol::Symbol;
/// 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: &[Symbol]) -> 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()
.zip(path)
.all(|(e, p)| e.data.as_interned_str().as_symbol() == *p)
}
pub fn in_derive_expn(span: Span) -> bool {
if let ExpnKind::Macro(MacroKind::Attr, n) = span.ctxt().outer_expn_data().kind {
n.as_str().contains("derive")
} else {
false
}
}

210
components/script_plugins/webidl_must_inherit.rs
View file

@ -1,210 +0,0 @@
/* 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 https://mozilla.org/MPL/2.0/. */
use rustc::hir;
use rustc::lint::{LateContext, LateLintPass, LintArray, LintContext, LintPass};
use rustc::ty;
use std::boxed;
use std::env;
use std::error::Error;
use std::fmt;
use std::fs;
use std::io;
use std::path;
use weedle;
declare_lint!(
WEBIDL_INHERIT_CORRECT,
Deny,
"Warn and report usage of incorrect webidl inheritance"
);
pub(crate) struct WebIdlPass {
symbols: crate::Symbols,
}
#[derive(Clone, Debug)]
pub struct ParentMismatchError {
name: String,
rust_parent: String,
webidl_parent: String,
}
impl fmt::Display for ParentMismatchError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(
f,
"webidl-rust inheritance mismatch, rust: {:?}, rust parent: {:?}, webidl parent: {:?}",
self.name, self.rust_parent, self.webidl_parent
)
}
}
impl Error for ParentMismatchError {
fn description(&self) -> &str {
"ParentMismatchError"
}
fn cause(&self) -> Option<&dyn Error> {
None
}
}
impl WebIdlPass {
pub fn new(symbols: crate::Symbols) -> WebIdlPass {
WebIdlPass { symbols }
}
}
fn get_ty_name(ty: &str) -> &str {
if let Some(i) = ty.rfind(':') {
&ty[i + 1..]
} else {
ty
}
}
fn get_manifest_dir() -> io::Result<path::PathBuf> {
match env::var("CARGO_MANIFEST_DIR") {
Ok(var) => {
let mut dir = path::PathBuf::new();
dir.push(var);
Ok(dir)
},
Err(env::VarError::NotPresent) => Err(io::Error::new(
io::ErrorKind::NotFound,
"CARGO_MANIFEST_DIR environment variable was not found",
)),
Err(env::VarError::NotUnicode(_)) => Err(io::Error::new(
io::ErrorKind::InvalidData,
"CARGO_MANIFEST_DIR environment variable's contents are non valid UTF-8",
)),
}
}
fn get_webidl_path(struct_name: &str) -> io::Result<path::PathBuf> {
let mut dir = get_manifest_dir()?;
dir.push("dom/webidls/");
dir.push(format!("{}.webidl", struct_name));
Ok(dir)
}
fn is_webidl_ty(symbols: &crate::Symbols, cx: &LateContext, ty: &ty::TyS) -> bool {
let mut ret = false;
ty.maybe_walk(|t| {
match t.kind {
ty::Adt(did, _substs) => {
if cx.tcx.has_attr(did.did, symbols.webidl) {
ret = true;
}
false
},
ty::Ref(..) => false, // don't recurse down &ptrs
ty::RawPtr(..) => false, // don't recurse down *ptrs
ty::FnDef(..) | ty::FnPtr(_) => false,
_ => true,
}
});
ret
}
fn check_inherits(code: &str, name: &str, parent_name: &str) -> Result<(), Box<dyn Error>> {
let idl = weedle::parse(code).expect("Invalid webidl provided");
let mut inherits = "";
for def in idl {
if let weedle::Definition::Interface(def) = def {
if let Some(parent) = def.inheritance {
inherits = parent.identifier.0;
break;
}
} else if let weedle::Definition::CallbackInterface(def) = def {
if let Some(parent) = def.inheritance {
inherits = parent.identifier.0;
break;
}
}
}
if inherits == parent_name {
return Ok(());
}
// If there is no parent, first field must be of type Reflector.
if inherits == "" && parent_name == "Reflector" {
return Ok(());
}
if inherits == "" &&
name == "PaintRenderingContext2D" &&
parent_name == "CanvasRenderingContext2D"
{
// PaintRenderingContext2D embeds a CanvasRenderingContext2D
// instead of a Reflector as an optimization,
// but this is fine since CanvasRenderingContext2D
// also has a reflector
return Ok(());
}
Err(boxed::Box::from(ParentMismatchError {
name: name.to_string(),
rust_parent: parent_name.to_string(),
webidl_parent: inherits.to_string(),
}))
}
fn check_webidl(name: &str, parent_name: &Option<String>) -> Result<(), Box<dyn Error>> {
let path = get_webidl_path(&name)?;
if let Some(parent) = parent_name {
let code = fs::read_to_string(path)?;
return check_inherits(&code, name, &parent);
}
Ok(())
}
impl LintPass for WebIdlPass {
fn name(&self) -> &'static str {
"ServoWebIDLPass"
}
fn get_lints(&self) -> LintArray {
lint_array!(WEBIDL_INHERIT_CORRECT)
}
}
impl<'a, 'tcx> LateLintPass<'a, 'tcx> for WebIdlPass {
fn check_item(&mut self, cx: &LateContext<'a, 'tcx>, item: &'tcx hir::Item) {
let def = match &item.kind {
hir::ItemKind::Struct(def, ..) => def,
_ => return,
};
let id = item.hir_id;
let def_id = cx.tcx.hir().local_def_id(id);
if !is_webidl_ty(&self.symbols, cx, cx.tcx.type_of(def_id)) {
return;
}
let item = match cx.tcx.hir().get(id) {
hir::Node::Item(item) => item,
_ => cx.tcx.hir().expect_item(cx.tcx.hir().get_parent_item(id)),
};
let parent_name = def.fields().iter().next().map(|field| {
let def_id = cx.tcx.hir().local_def_id(field.hir_id);
let ty = cx.tcx.type_of(def_id).to_string();
get_ty_name(&ty).to_string()
});
let struct_name = item.ident.to_string();
match check_webidl(&struct_name, &parent_name) {
Ok(()) => {},
Err(e) => {
let description = format!("{}", e);
cx.span_lint(WEBIDL_INHERIT_CORRECT, item.ident.span, &description)
},
};
}
}