Upgrade rust to f93ab64d4a1a7ee91759a1594ab2a426b6cc657e/rustc-1.5.0-dev.

components/plugins/utils.rs

@@ -2,12 +2,12 @@
  * 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::ast_map;
-use rustc::lint::Context;
+use rustc::front::map as ast_map;
+use rustc::lint::LateContext;
 use rustc::middle::def;
 use rustc::middle::def_id::DefId;
+use rustc_front::hir;
 use syntax::ast;
-use syntax::ast::{TyPath, Path, AngleBracketedParameters, PathSegment, Ty};
 use syntax::attr::mark_used;
 use syntax::ptr::P;
 
@@ -15,16 +15,16 @@ use syntax::ptr::P;
 /// Matches a type with a provided string, and returns its type parameters if successful
 ///
 /// Try not to use this for types defined in crates you own, use match_lang_ty instead (for lint passes)
-pub fn match_ty_unwrap<'a>(ty: &'a Ty, segments: &[&str]) -> Option<&'a [P<Ty>]> {
+pub fn match_ty_unwrap<'a>(ty: &'a ast::Ty, segments: &[&str]) -> Option<&'a [P<ast::Ty>]> {
     match ty.node {
-        TyPath(_, Path { segments: ref seg, .. }) => {
-            // So ast::Path isn't the full path, just the tokens that were provided.
+        ast::TyPath(_, 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(&PathSegment { parameters: AngleBracketedParameters(ref a), .. }) => {
+                    Some(&ast::PathSegment { parameters: ast::AngleBracketedParameters(ref a), .. }) => {
                         Some(&a.types)
                     }
                     _ => None
@@ -38,9 +38,9 @@ pub fn match_ty_unwrap<'a>(ty: &'a Ty, segments: &[&str]) -> Option<&'a [P<Ty>]>
 }
 
 /// Checks if a type has a #[servo_lang = "str"] attribute
-pub fn match_lang_ty(cx: &Context, ty: &Ty, value: &str) -> bool {
+pub fn match_lang_ty(cx: &LateContext, ty: &hir::Ty, value: &str) -> bool {
     match ty.node {
-        TyPath(..) => {},
+        hir::TyPath(..) => {},
         _ => return false,
     }
 
@@ -52,7 +52,7 @@ pub fn match_lang_ty(cx: &Context, ty: &Ty, value: &str) -> bool {
     match_lang_did(cx, def_id, value)
 }
 
-pub fn match_lang_did(cx: &Context, did: DefId, value: &str) -> bool {
+pub fn match_lang_did(cx: &LateContext, did: DefId, value: &str) -> bool {
     cx.tcx.get_attrs(did).iter().any(|attr| {
         match attr.node.value.node {
             ast::MetaNameValue(ref name, ref val) if &**name == "servo_lang" => {
@@ -75,14 +75,14 @@ pub fn unsafe_context(map: &ast_map::Map, id: ast::NodeId) -> bool {
     match map.find(map.get_parent(id)) {
         Some(ast_map::NodeImplItem(itm)) => {
             match itm.node {
-                ast::MethodImplItem(ref sig, _) => sig.unsafety == ast::Unsafety::Unsafe,
+                hir::MethodImplItem(ref sig, _) => sig.unsafety == hir::Unsafety::Unsafe,
                 _ => false
             }
         },
         Some(ast_map::NodeItem(itm)) => {
             match itm.node {
-                ast::ItemFn(_, style, _, _, _, _) => match style {
-                    ast::Unsafety::Unsafe => true,
+                hir::ItemFn(_, style, _, _, _, _) => match style {
+                    hir::Unsafety::Unsafe => true,
                     _ => false,
                 },
                 _ => false,
@@ -96,7 +96,7 @@ pub fn unsafe_context(map: &ast_map::Map, id: ast::NodeId) -> bool {
 /// 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: &Context, def_id: DefId, path: &[&str]) -> bool {
+pub fn match_def_path(cx: &LateContext, def_id: DefId, path: &[&str]) -> bool {
     cx.tcx.with_path(def_id, |iter| iter.map(|elem| elem.name())
         .zip(path.iter()).all(|(nm, p)| &nm.as_str() == p))
 }