Skip to content

Commit 4f52dab

Browse files
dtolnaydtolnay
authored
Merge pull request #504 from dtolnay/parsens
Remove redundant namespaces passed around by parser
2 parents 909b8fc + 313cc0a commit 4f52dab

File tree

1 file changed

+28
-29
lines changed

1 file changed

+28
-29
lines changed

‎syntax/parse.rs

Lines changed: 28 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -43,7 +43,7 @@ pub fn parse_items(
4343
Item::ForeignMod(foreign_mod) => {
4444
parse_foreign_mod(cx, foreign_mod, &mut apis, trusted, namespace)
4545
}
46-
Item::Impl(item) => match parse_impl(item, namespace) {
46+
Item::Impl(item) => match parse_impl(item) {
4747
Ok(imp) => apis.push(imp),
4848
Err(err) => cx.push(err),
4949
},
@@ -95,7 +95,7 @@ fn parse_struct(cx: &mut Errors, item: ItemStruct, namespace: &Namespace) -> Res
9595
.map(|field| {
9696
Ok(Var {
9797
ident: field.ident.unwrap(),
98-
ty: parse_type(&field.ty, &namespace)?,
98+
ty: parse_type(&field.ty)?,
9999
})
100100
})
101101
.collect::<Result<_>>()?;
@@ -438,7 +438,7 @@ fn parse_extern_fn(
438438
}
439439
_ => return Err(Error::new_spanned(arg, "unsupported signature")),
440440
};
441-
let ty = parse_type(&arg.ty, &namespace)?;
441+
let ty = parse_type(&arg.ty)?;
442442
if ident != "self" {
443443
args.push_value(Var { ident, ty });
444444
if let Some(comma) = comma {
@@ -468,7 +468,7 @@ fn parse_extern_fn(
468468
}
469469

470470
let mut throws_tokens = None;
471-
let ret = parse_return_type(&foreign_fn.sig.output, &mut throws_tokens, &namespace)?;
471+
let ret = parse_return_type(&foreign_fn.sig.output, &mut throws_tokens)?;
472472
let throws = throws_tokens.is_some();
473473
let unsafety = foreign_fn.sig.unsafety;
474474
let fn_token = foreign_fn.sig.fn_token;
@@ -559,7 +559,7 @@ fn parse_extern_verbatim(
559559
}
560560
}
561561

562-
fn parse_impl(imp: ItemImpl, namespace: &Namespace) -> Result<Api> {
562+
fn parse_impl(imp: ItemImpl) -> Result<Api> {
563563
if !imp.items.is_empty() {
564564
let mut span = Group::new(Delimiter::Brace, TokenStream::new());
565565
span.set_span(imp.brace_token.span);
@@ -585,7 +585,7 @@ fn parse_impl(imp: ItemImpl, namespace: &Namespace) -> Result<Api> {
585585

586586
Ok(Api::Impl(Impl {
587587
impl_token: imp.impl_token,
588-
ty: parse_type(&self_ty, namespace)?,
588+
ty: parse_type(&self_ty)?,
589589
brace_token: imp.brace_token,
590590
}))
591591
}
@@ -634,20 +634,20 @@ fn parse_include(input: ParseStream) -> Result<Include> {
634634
Err(input.error("expected \"quoted/path/to\" or <bracketed/path/to>"))
635635
}
636636

637-
fn parse_type(ty: &RustType, namespace: &Namespace) -> Result<Type> {
637+
fn parse_type(ty: &RustType) -> Result<Type> {
638638
match ty {
639-
RustType::Reference(ty) => parse_type_reference(ty, namespace),
640-
RustType::Path(ty) => parse_type_path(ty, namespace),
641-
RustType::Slice(ty) => parse_type_slice(ty, namespace),
642-
RustType::Array(ty) => parse_type_array(ty, namespace),
643-
RustType::BareFn(ty) => parse_type_fn(ty, namespace),
639+
RustType::Reference(ty) => parse_type_reference(ty),
640+
RustType::Path(ty) => parse_type_path(ty),
641+
RustType::Slice(ty) => parse_type_slice(ty),
642+
RustType::Array(ty) => parse_type_array(ty),
643+
RustType::BareFn(ty) => parse_type_fn(ty),
644644
RustType::Tuple(ty) if ty.elems.is_empty() => Ok(Type::Void(ty.paren_token.span)),
645645
_ => Err(Error::new_spanned(ty, "unsupported type")),
646646
}
647647
}
648648

649-
fn parse_type_reference(ty: &TypeReference, namespace: &Namespace) -> Result<Type> {
650-
let inner = parse_type(&ty.elem, namespace)?;
649+
fn parse_type_reference(ty: &TypeReference) -> Result<Type> {
650+
let inner = parse_type(&ty.elem)?;
651651
let which = match &inner {
652652
Type::Ident(ident) if ident.rust == "str" => {
653653
if ty.mutability.is_some() {
@@ -673,7 +673,7 @@ fn parse_type_reference(ty: &TypeReference, namespace: &Namespace) -> Result<Typ
673673
})))
674674
}
675675

676-
fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
676+
fn parse_type_path(ty: &TypePath) -> Result<Type> {
677677
let path = &ty.path;
678678
if ty.qself.is_none() && path.leading_colon.is_none() && path.segments.len() == 1 {
679679
let segment = &path.segments[0];
@@ -683,7 +683,7 @@ fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
683683
PathArguments::AngleBracketed(generic) => {
684684
if ident == "UniquePtr" && generic.args.len() == 1 {
685685
if let GenericArgument::Type(arg) = &generic.args[0] {
686-
let inner = parse_type(arg, namespace)?;
686+
let inner = parse_type(arg)?;
687687
return Ok(Type::UniquePtr(Box::new(Ty1 {
688688
name: ident,
689689
langle: generic.lt_token,
@@ -693,7 +693,7 @@ fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
693693
}
694694
} else if ident == "CxxVector" && generic.args.len() == 1 {
695695
if let GenericArgument::Type(arg) = &generic.args[0] {
696-
let inner = parse_type(arg, namespace)?;
696+
let inner = parse_type(arg)?;
697697
return Ok(Type::CxxVector(Box::new(Ty1 {
698698
name: ident,
699699
langle: generic.lt_token,
@@ -703,7 +703,7 @@ fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
703703
}
704704
} else if ident == "Box" && generic.args.len() == 1 {
705705
if let GenericArgument::Type(arg) = &generic.args[0] {
706-
let inner = parse_type(arg, namespace)?;
706+
let inner = parse_type(arg)?;
707707
return Ok(Type::RustBox(Box::new(Ty1 {
708708
name: ident,
709709
langle: generic.lt_token,
@@ -713,7 +713,7 @@ fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
713713
}
714714
} else if ident == "Vec" && generic.args.len() == 1 {
715715
if let GenericArgument::Type(arg) = &generic.args[0] {
716-
let inner = parse_type(arg, namespace)?;
716+
let inner = parse_type(arg)?;
717717
return Ok(Type::RustVec(Box::new(Ty1 {
718718
name: ident,
719719
langle: generic.lt_token,
@@ -723,7 +723,7 @@ fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
723723
}
724724
} else if ident == "Pin" && generic.args.len() == 1 {
725725
if let GenericArgument::Type(arg) = &generic.args[0] {
726-
let inner = parse_type(arg, namespace)?;
726+
let inner = parse_type(arg)?;
727727
let pin_token = kw::Pin(ident.span());
728728
if let Type::Ref(mut inner) = inner {
729729
inner.pinned = true;
@@ -740,16 +740,16 @@ fn parse_type_path(ty: &TypePath, namespace: &Namespace) -> Result<Type> {
740740
Err(Error::new_spanned(ty, "unsupported type"))
741741
}
742742

743-
fn parse_type_slice(ty: &TypeSlice, namespace: &Namespace) -> Result<Type> {
744-
let inner = parse_type(&ty.elem, namespace)?;
743+
fn parse_type_slice(ty: &TypeSlice) -> Result<Type> {
744+
let inner = parse_type(&ty.elem)?;
745745
Ok(Type::Slice(Box::new(Slice {
746746
bracket: ty.bracket_token,
747747
inner,
748748
})))
749749
}
750750

751-
fn parse_type_array(ty: &TypeArray, namespace: &Namespace) -> Result<Type> {
752-
let inner = parse_type(&ty.elem, namespace)?;
751+
fn parse_type_array(ty: &TypeArray) -> Result<Type> {
752+
let inner = parse_type(&ty.elem)?;
753753

754754
let len_expr = if let Expr::Lit(lit) = &ty.len {
755755
lit
@@ -778,7 +778,7 @@ fn parse_type_array(ty: &TypeArray, namespace: &Namespace) -> Result<Type> {
778778
})))
779779
}
780780

781-
fn parse_type_fn(ty: &TypeBareFn, namespace: &Namespace) -> Result<Type> {
781+
fn parse_type_fn(ty: &TypeBareFn) -> Result<Type> {
782782
if ty.lifetimes.is_some() {
783783
return Err(Error::new_spanned(
784784
ty,
@@ -796,7 +796,7 @@ fn parse_type_fn(ty: &TypeBareFn, namespace: &Namespace) -> Result<Type> {
796796
.iter()
797797
.enumerate()
798798
.map(|(i, arg)| {
799-
let ty = parse_type(&arg.ty, namespace)?;
799+
let ty = parse_type(&arg.ty)?;
800800
let ident = match &arg.name {
801801
Some(ident) => ident.0.clone(),
802802
None => format_ident!("_{}", i),
@@ -805,7 +805,7 @@ fn parse_type_fn(ty: &TypeBareFn, namespace: &Namespace) -> Result<Type> {
805805
})
806806
.collect::<Result<_>>()?;
807807
let mut throws_tokens = None;
808-
let ret = parse_return_type(&ty.output, &mut throws_tokens, namespace)?;
808+
let ret = parse_return_type(&ty.output, &mut throws_tokens)?;
809809
let throws = throws_tokens.is_some();
810810
Ok(Type::Fn(Box::new(Signature {
811811
unsafety: ty.unsafety,
@@ -823,7 +823,6 @@ fn parse_type_fn(ty: &TypeBareFn, namespace: &Namespace) -> Result<Type> {
823823
fn parse_return_type(
824824
ty: &ReturnType,
825825
throws_tokens: &mut Option<(kw::Result, Token![<], Token![>])>,
826-
namespace: &Namespace,
827826
) -> Result<Option<Type>> {
828827
let mut ret = match ty {
829828
ReturnType::Default => return Ok(None),
@@ -845,7 +844,7 @@ fn parse_return_type(
845844
}
846845
}
847846
}
848-
match parse_type(ret, namespace)? {
847+
match parse_type(ret)? {
849848
Type::Void(_) => Ok(None),
850849
ty => Ok(Some(ty)),
851850
}

0 commit comments

Comments
 (0)