From f126eacd115415b0814ceb4a1c71380a0b2eb752 Mon Sep 17 00:00:00 2001 From: John Clements Date: Fri, 4 Jul 2014 12:05:43 -0700 Subject: [PATCH] comments, whitespace, rename NameFinderContext to PatIdentFinder --- src/libsyntax/ast.rs | 18 ++++++++++++------ src/libsyntax/ext/expand.rs | 34 +++++++++++++++------------------- 2 files changed, 27 insertions(+), 25 deletions(-) diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 237d0660a41d..e2a74ba4dfc9 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -453,10 +453,10 @@ pub enum Expr_ { ExprCast(Gc, P), ExprIf(Gc, P, Option>), ExprWhile(Gc, P), - // FIXME #6993: change to Option + // FIXME #6993: change to Option ... or not, if these are hygienic. ExprForLoop(Gc, Gc, P, Option), // Conditionless loop (can be exited with break, cont, or ret) - // FIXME #6993: change to Option + // FIXME #6993: change to Option ... or not, if these are hygienic. ExprLoop(P, Option), ExprMatch(Gc, Vec), ExprFnBlock(P, P), @@ -468,9 +468,8 @@ pub enum Expr_ { ExprField(Gc, SpannedIdent, Vec>), ExprIndex(Gc, Gc), - /// Expression that looks like a "name". For example, - /// `std::slice::from_elem::` is an ExprPath that's the "name" part - /// of a function call. + /// Variable reference, possibly containing `::` and/or + /// type parameters, e.g. foo::bar:: ExprPath(Path), ExprAddrOf(Mutability, Gc), @@ -643,6 +642,8 @@ pub struct TypeField { pub span: Span, } +/// Represents a required method in a trait declaration, +/// one without a default implementation #[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)] pub struct TypeMethod { pub ident: Ident, @@ -656,6 +657,8 @@ pub struct TypeMethod { pub vis: Visibility, } +/// Represents a method declaration in a trait declaration, possibly +/// including a default implementation // A trait method is either required (meaning it doesn't have an // implementation, just a signature) or provided (meaning it has a default // implementation). @@ -741,6 +744,7 @@ impl fmt::Show for Onceness { } } +/// Represents the type of a closure #[deriving(PartialEq, Eq, Encodable, Decodable, Hash)] pub struct ClosureTy { pub lifetimes: Vec, @@ -809,6 +813,7 @@ pub struct InlineAsm { pub dialect: AsmDialect } +/// represents an argument in a function header #[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)] pub struct Arg { pub ty: P, @@ -836,7 +841,7 @@ impl Arg { } } -// represents the header (not the body) of a function declaration +/// represents the header (not the body) of a function declaration #[deriving(Clone, PartialEq, Eq, Encodable, Decodable, Hash)] pub struct FnDecl { pub inputs: Vec, @@ -1107,6 +1112,7 @@ pub enum Item_ { ItemTy(P, Generics), ItemEnum(EnumDef, Generics), ItemStruct(Gc, Generics), + /// Represents a Trait Declaration ItemTrait(Generics, Sized, Vec , Vec ), ItemImpl(Generics, Option, // (optional) trait this impl implements diff --git a/src/libsyntax/ext/expand.rs b/src/libsyntax/ext/expand.rs index 253102ba5de6..a4d32a1c0205 100644 --- a/src/libsyntax/ext/expand.rs +++ b/src/libsyntax/ext/expand.rs @@ -267,7 +267,8 @@ fn expand_loop_block(loop_block: P, } } -// eval $e with a new exts frame: +// eval $e with a new exts frame. +// must be a macro so that $e isn't evaluated too early. macro_rules! with_exts_frame ( ($extsboxexpr:expr,$macros_escape:expr,$e:expr) => ({$extsboxexpr.push_frame(); @@ -609,7 +610,7 @@ fn expand_non_macro_stmt(s: &Stmt, fld: &mut MacroExpander) } = **local; // expand the pat (it might contain macro uses): let expanded_pat = fld.fold_pat(pat); - // find the pat_idents in the pattern: + // find the PatIdents in the pattern: // oh dear heaven... this is going to include the enum // names, as well... but that should be okay, as long as // the new names are gensyms for the old ones. @@ -691,39 +692,34 @@ fn expand_arm(arm: &ast::Arm, fld: &mut MacroExpander) -> ast::Arm { -// a visitor that extracts the pat_ident (binding) paths -// from a given thingy and puts them in a mutable -// array +/// A visitor that extracts the PatIdent (binding) paths +/// from a given thingy and puts them in a mutable +/// array #[deriving(Clone)] -struct NameFinderContext { +struct PatIdentFinder { ident_accumulator: Vec , } -impl Visitor<()> for NameFinderContext { +impl Visitor<()> for PatIdentFinder { fn visit_pat(&mut self, pattern: &ast::Pat, _: ()) { match *pattern { - // we found a pat_ident! - ast::Pat { - id: _, - node: ast::PatIdent(_, ref path1, ref inner), - span: _ - } => { + ast::Pat { id: _, node: ast::PatIdent(_, ref path1, ref inner), span: _ } => { self.ident_accumulator.push(path1.node); - // visit optional subpattern of pat_ident: + // visit optional subpattern of PatIdent: for subpat in inner.iter() { self.visit_pat(&**subpat, ()) } } - // use the default traversal for non-pat_idents + // use the default traversal for non-PatIdents _ => visit::walk_pat(self, pattern, ()) } } } -// find the pat_ident paths in a pattern +/// find the PatIdent paths in a pattern fn pattern_bindings(pat : &ast::Pat) -> Vec { - let mut name_finder = NameFinderContext{ident_accumulator:Vec::new()}; + let mut name_finder = PatIdentFinder{ident_accumulator:Vec::new()}; name_finder.visit_pat(pat,()); name_finder.ident_accumulator } @@ -1028,7 +1024,7 @@ fn original_span(cx: &ExtCtxt) -> Gc { #[cfg(test)] mod test { use super::{pattern_bindings, expand_crate, contains_macro_escape}; - use super::{NameFinderContext}; + use super::{PatIdentFinder}; use ast; use ast::{Attribute_, AttrOuter, MetaWord}; use attr; @@ -1167,7 +1163,7 @@ mod test { // find the pat_ident paths in a crate fn crate_bindings(the_crate : &ast::Crate) -> Vec { - let mut name_finder = NameFinderContext{ident_accumulator:Vec::new()}; + let mut name_finder = PatIdentFinder{ident_accumulator:Vec::new()}; visit::walk_crate(&mut name_finder, the_crate, ()); name_finder.ident_accumulator }