fluencelabs/wasm-bindgen
1
0
Fork 0
mirror of https://github.com/fluencelabs/wasm-bindgen synced 2025-06-22 17:21:35 +00:00
Code Issues Projects Releases Wiki Activity

Use argument names instead of argument type names if possible

Browse Source
This commit is contained in:
Anton Danilkin
2018-08-09 21:51:41 +03:00
parent 703b1ab91d
commit 131f223241
1 changed files with 48 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
crates/webidl/src/util.rs
View File

@ -1,5 +1,6 @@
use std::iter::FromIterator; use std::iter::FromIterator;
use std::iter; use std::iter;
use std::collections::BTreeMap;
use backend; use backend;
use backend::util::{ident_ty, leading_colon_path_ty, raw_ident, rust_ident}; use backend::util::{ident_ty, leading_colon_path_ty, raw_ident, rust_ident};
@ -946,12 +947,12 @@ impl<'src> FirstPassRecord<'src> {
/// ///
/// Return option that contains a value if the conversion succeeds. /// Return option that contains a value if the conversion succeeds.
/// The value is a vector of argument variants. /// The value is a vector of argument variants.
/// Each variant is a vector of converted argument types and type names. /// Each variant is a vector of original arguments, converted argument types and type names.
fn get_variants( fn get_variants(
&self, &self,
arguments: &[Argument], arguments: &'src [Argument],
kind: &backend::ast::ImportFunctionKind, kind: &backend::ast::ImportFunctionKind,
) -> Option<Vec<Vec<(syn::ArgCaptured, Option<String>)>>> ) -> Option<Vec<Vec<(Option<&'src Argument>, (syn::ArgCaptured, Option<String>))>>>
{ {
let arguments_possibilities = { let arguments_possibilities = {
fn get_argument_possibilities(record: &FirstPassRecord, argument: &Argument) -> Option<Vec<(syn::Type, String)>> { fn get_argument_possibilities(record: &FirstPassRecord, argument: &Argument) -> Option<Vec<(syn::Type, String)>> {
@ -1023,7 +1024,15 @@ impl<'src> FirstPassRecord<'src> {
.. ..
} = kind { } = kind {
let mut res = Vec::with_capacity(arguments.len() + 1); let mut res = Vec::with_capacity(arguments.len() + 1);
res.push((simple_fn_arg(raw_ident("self_"), shared_ref(ty.clone())), None)); res.push(
(
None,
(
simple_fn_arg(raw_ident("self_"), shared_ref(ty.clone())),
None,
),
)
);
res res
} else { } else {
Vec::with_capacity(arguments.len()) Vec::with_capacity(arguments.len())
@ -1035,11 +1044,14 @@ impl<'src> FirstPassRecord<'src> {
}; };
res.push( res.push(
( (
simple_fn_arg( Some(argument),
rust_ident(&single.identifier.0.to_snake_case()), (
argument_possibility.0.clone() simple_fn_arg(
rust_ident(&single.identifier.0.to_snake_case()),
argument_possibility.0.clone()
),
Some(argument_possibility.1.clone()),
), ),
Some(argument_possibility.1.clone()),
) )
); );
} }
@ -1065,8 +1077,8 @@ impl<'src> FirstPassRecord<'src> {
{ {
let rust_name = if overloaded && !arguments.is_empty() { let rust_name = if overloaded && !arguments.is_empty() {
let mut argument_type_names = String::new(); let mut argument_type_names = String::new();
for arg in arguments { for argument in arguments {
let arg = match arg { let argument = match argument {
Argument::Single(single) => single, Argument::Single(single) => single,
Argument::Variadic(_) => return None, Argument::Variadic(_) => return None,
}; };
@ -1074,9 +1086,9 @@ impl<'src> FirstPassRecord<'src> {
argument_type_names.push_str("_and_"); argument_type_names.push_str("_and_");
} }
if same_argument_names { if same_argument_names {
arg.type_.type_.push_type_name(self, &mut argument_type_names); argument.type_.type_.push_type_name(self, &mut argument_type_names);
} else { } else {
argument_type_names.push_str(&arg.identifier.0.to_snake_case()); argument_type_names.push_str(&argument.identifier.0.to_snake_case());
} }
} }
if name == "new" { if name == "new" {
@ -1096,13 +1108,22 @@ impl<'src> FirstPassRecord<'src> {
let variants = self.get_variants(arguments, &kind)?; let variants = self.get_variants(arguments, &kind)?;
let multiple_variants = variants.len() > 1; let multiple_variants = variants.len() > 1;
let mut arguments_count_variants_count = BTreeMap::new();
for variant in &variants {
arguments_count_variants_count
.entry(variant.len())
.and_modify(|variants_count| { *variants_count += 1usize; })
.or_insert(1usize);
}
let mut result = Vec::new(); let mut result = Vec::new();
for variant in variants { for variant in variants {
let (variant_types, variant_names): (Vec<_>, Vec<_>) = variant.into_iter().unzip(); let (arguments, variant_types_variant_names): (Vec<_>, Vec<(_, _)>) = variant.into_iter().unzip();
let (variant_types, variant_names): (Vec<_>, Vec<_>) = variant_types_variant_names.into_iter().unzip();
let variant_names_len = variant_names.len();
let rust_name = if multiple_variants { let rust_name = if multiple_variants {
let mut rust_name = rust_name.clone(); let mut rust_name = rust_name.clone();
let mut first = true; let mut first = true;
for variant_name in variant_names { for (argument, variant_name) in arguments.iter().zip(variant_names) {
if let Some(type_name) = variant_name { if let Some(type_name) = variant_name {
if first { if first {
rust_name.push_str("_using_"); rust_name.push_str("_using_");
@ -1110,7 +1131,19 @@ impl<'src> FirstPassRecord<'src> {
} else { } else {
rust_name.push_str("_and_"); rust_name.push_str("_and_");
} }
rust_name.push_str(&type_name); if arguments_count_variants_count[&variant_names_len] == 1 {
if let Some(argument) = argument {
let argument = match argument {
Argument::Single(single) => single,
Argument::Variadic(_) => return None,
};
rust_name.push_str(&argument.identifier.0.to_snake_case());
} else {
rust_name.push_str(&type_name);
}
} else {
rust_name.push_str(&type_name);
}
} }
} }
rust_name rust_name