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.

1 files changed, 0 insertions, 210 deletions

diff --git a/components/script_plugins/webidl_must_inherit.rs b/components/script_plugins/webidl_must_inherit.rs
deleted file mode 100644
index 95d8ad386a9..00000000000
--- a/components/script_plugins/webidl_must_inherit.rs
+++ /dev/null
@@ -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)
-            },
-        };
-    }
-}