From 26a2a1deda5da262a48a01d017cf99aca5f089c9 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 25 Mar 2020 17:26:43 -0700 Subject: [PATCH] Collect typecheck context into a struct --- syntax/check.rs | 139 +++++++++++++++++++++++++++--------------------- 1 file changed, 77 insertions(+), 62 deletions(-) diff --git a/syntax/check.rs b/syntax/check.rs index f5ccba91..5a3590ff 100644 --- a/syntax/check.rs +++ b/syntax/check.rs @@ -4,139 +4,144 @@ use proc_macro2::{Delimiter, Group, Ident, TokenStream}; use quote::quote; use syn::{Error, Result}; +struct Check<'a> { + apis: &'a [Api], + types: &'a Types<'a>, + errors: &'a mut Vec, +} + pub(crate) fn typecheck(apis: &[Api], types: &Types) -> Result<()> { - let ref mut errors = Vec::new(); + let mut errors = Vec::new(); + let mut cx = Check { + apis, + types, + errors: &mut errors, + }; + do_typecheck(&mut cx); + combine_errors(errors) +} - for ty in types { +fn do_typecheck(cx: &mut Check) { + for ty in cx.types { match ty { - Type::Ident(ident) => check_type_ident(errors, types, ident), - Type::RustBox(ptr) => check_type_box(errors, types, ptr), - Type::UniquePtr(ptr) => check_type_unique_ptr(errors, types, ptr), - Type::Ref(ty) => check_type_ref(errors, ty), - Type::Fn(_) => errors.push(unimplemented_fn_type(ty)), + Type::Ident(ident) => check_type_ident(cx, ident), + Type::RustBox(ptr) => check_type_box(cx, ptr), + Type::UniquePtr(ptr) => check_type_unique_ptr(cx, ptr), + Type::Ref(ty) => check_type_ref(cx, ty), + Type::Fn(_) => cx.errors.push(unimplemented_fn_type(ty)), _ => {} } } - for api in apis { + for api in cx.apis { match api { - Api::Struct(strct) => check_api_struct(errors, types, strct), - Api::CxxFunction(efn) | Api::RustFunction(efn) => check_api_fn(errors, types, efn), + Api::Struct(strct) => check_api_struct(cx, strct), + Api::CxxFunction(efn) | Api::RustFunction(efn) => check_api_fn(cx, efn), _ => {} } } - for api in apis { + for api in cx.apis { if let Api::CxxFunction(efn) = api { - errors.extend(check_mut_return_restriction(efn).err()); + check_mut_return_restriction(cx, efn); } if let Api::CxxFunction(efn) | Api::RustFunction(efn) = api { - errors.extend(check_multiple_arg_lifetimes(efn).err()); + check_multiple_arg_lifetimes(cx, efn); } } - ident::check_all(apis, errors); - - let mut iter = errors.drain(..); - let mut all_errors = match iter.next() { - Some(err) => err, - None => return Ok(()), - }; - for err in iter { - all_errors.combine(err); - } - Err(all_errors) + ident::check_all(cx.apis, cx.errors); } -fn check_type_ident(errors: &mut Vec, types: &Types, ident: &Ident) { +fn check_type_ident(cx: &mut Check, ident: &Ident) { if Atom::from(ident).is_none() - && !types.structs.contains_key(ident) - && !types.cxx.contains(ident) - && !types.rust.contains(ident) + && !cx.types.structs.contains_key(ident) + && !cx.types.cxx.contains(ident) + && !cx.types.rust.contains(ident) { - errors.push(unsupported_type(ident)); + cx.errors.push(unsupported_type(ident)); } } -fn check_type_box(errors: &mut Vec, types: &Types, ptr: &Ty1) { +fn check_type_box(cx: &mut Check, ptr: &Ty1) { if let Type::Ident(ident) = &ptr.inner { - if types.cxx.contains(ident) { - errors.push(unsupported_cxx_type_in_box(ptr)); + if cx.types.cxx.contains(ident) { + cx.errors.push(unsupported_cxx_type_in_box(ptr)); } if Atom::from(ident).is_none() { return; } } - errors.push(unsupported_box_target(ptr)); + cx.errors.push(unsupported_box_target(ptr)); } -fn check_type_unique_ptr(errors: &mut Vec, types: &Types, ptr: &Ty1) { +fn check_type_unique_ptr(cx: &mut Check, ptr: &Ty1) { if let Type::Ident(ident) = &ptr.inner { - if types.rust.contains(ident) { - errors.push(unsupported_rust_type_in_unique_ptr(ptr)); + if cx.types.rust.contains(ident) { + cx.errors.push(unsupported_rust_type_in_unique_ptr(ptr)); } match Atom::from(ident) { None | Some(CxxString) => return, _ => {} } } - errors.push(unsupported_unique_ptr_target(ptr)); + cx.errors.push(unsupported_unique_ptr_target(ptr)); } -fn check_type_ref(errors: &mut Vec, ty: &Ref) { +fn check_type_ref(cx: &mut Check, ty: &Ref) { if let Type::Void(_) = ty.inner { - errors.push(unsupported_reference_type(ty)); + cx.errors.push(unsupported_reference_type(ty)); } } -fn check_api_struct(errors: &mut Vec, types: &Types, strct: &Struct) { +fn check_api_struct(cx: &mut Check, strct: &Struct) { if strct.fields.is_empty() { - errors.push(struct_empty(strct)); + cx.errors.push(struct_empty(strct)); } for field in &strct.fields { - if is_unsized(&field.ty, types) { - errors.push(field_by_value(field, types)); + if is_unsized(cx, &field.ty) { + cx.errors.push(field_by_value(field, cx.types)); } } } -fn check_api_fn(errors: &mut Vec, types: &Types, efn: &ExternFn) { +fn check_api_fn(cx: &mut Check, efn: &ExternFn) { for arg in &efn.args { - if is_unsized(&arg.ty, types) { - errors.push(argument_by_value(arg, types)); + if is_unsized(cx, &arg.ty) { + cx.errors.push(argument_by_value(arg, cx.types)); } } if let Some(ty) = &efn.ret { - if is_unsized(ty, types) { - errors.push(return_by_value(ty, types)); + if is_unsized(cx, ty) { + cx.errors.push(return_by_value(ty, cx.types)); } } } -fn check_mut_return_restriction(efn: &ExternFn) -> Result<()> { +fn check_mut_return_restriction(cx: &mut Check, efn: &ExternFn) { match &efn.ret { Some(Type::Ref(ty)) if ty.mutability.is_some() => {} - _ => return Ok(()), + _ => return, } for arg in &efn.args { if let Type::Ref(ty) = &arg.ty { if ty.mutability.is_some() { - return Ok(()); + return; } } } - Err(Error::new_spanned( + cx.errors.push(Error::new_spanned( efn, "&mut return type is not allowed unless there is a &mut argument", - )) + )); } -fn check_multiple_arg_lifetimes(efn: &ExternFn) -> Result<()> { +fn check_multiple_arg_lifetimes(cx: &mut Check, efn: &ExternFn) { match &efn.ret { Some(Type::Ref(_)) => {} - _ => return Ok(()), + _ => return, } let mut reference_args = 0; @@ -146,23 +151,33 @@ fn check_multiple_arg_lifetimes(efn: &ExternFn) -> Result<()> { } } - if reference_args == 1 { - Ok(()) - } else { - Err(Error::new_spanned( + if reference_args != 1 { + cx.errors.push(Error::new_spanned( efn, "functions that return a reference must take exactly one input reference", - )) + )); } } -fn is_unsized(ty: &Type, types: &Types) -> bool { +fn is_unsized(cx: &mut Check, ty: &Type) -> bool { let ident = match ty { Type::Ident(ident) => ident, Type::Void(_) => return true, _ => return false, }; - ident == CxxString || types.cxx.contains(ident) || types.rust.contains(ident) + ident == CxxString || cx.types.cxx.contains(ident) || cx.types.rust.contains(ident) +} + +fn combine_errors(errors: Vec) -> Result<()> { + let mut iter = errors.into_iter(); + let mut all_errors = match iter.next() { + Some(err) => err, + None => return Ok(()), + }; + for err in iter { + all_errors.combine(err); + } + Err(all_errors) } fn describe(ty: &Type, types: &Types) -> String {