From d9b30d016caf336e57ee6d88495ff80652658842 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 12 Jun 2024 16:23:33 +0900 Subject: [PATCH 01/13] for_each_binding_ident --- crates/swc_ecma_utils/src/lib.rs | 37 ++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/crates/swc_ecma_utils/src/lib.rs b/crates/swc_ecma_utils/src/lib.rs index f69df5749e2c..2336565fcab5 100644 --- a/crates/swc_ecma_utils/src/lib.rs +++ b/crates/swc_ecma_utils/src/lib.rs @@ -2373,6 +2373,8 @@ pub struct DestructuringFinder { } /// Finds all **binding** idents of `node`. +/// +/// If you want to avoid allocation, use [`for_each_binding_ident`] instead. pub fn find_pat_ids(node: &T) -> Vec where T: VisitWith>, @@ -2397,6 +2399,41 @@ impl Visit for DestructuringFinder { fn visit_prop_name(&mut self, _: &PropName) {} } +/// Finds all **binding** idents of variables. +pub struct BindingIdentifierVisitor +where + F: for<'a> FnMut(&'a Ident), +{ + op: F, +} + +/// Finds all **binding** idents of `node`. +pub fn for_each_binding_ident(node: &T, op: F) +where + T: VisitWith>, + F: for<'a> FnMut(&'a Ident), +{ + let mut v = BindingIdentifierVisitor { op }; + node.visit_with(&mut v); +} + +impl Visit for BindingIdentifierVisitor +where + F: for<'a> FnMut(&'a Ident), +{ + noop_visit_type!(); + + /// No-op (we don't care about expressions) + fn visit_expr(&mut self, _: &Expr) {} + + fn visit_ident(&mut self, i: &Ident) { + (self.op)(i); + } + + /// No-op (we don't care about expressions) + fn visit_prop_name(&mut self, _: &PropName) {} +} + pub fn is_valid_ident(s: &JsWord) -> bool { if s.len() == 0 { return false; From 327966437dcf0c700c2225005da3b9b75fa3eed4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 12 Jun 2024 16:29:16 +0900 Subject: [PATCH 02/13] no-dupe-args --- .../swc_ecma_lints/src/rules/no_dupe_args.rs | 79 ++++++++++--------- 1 file changed, 42 insertions(+), 37 deletions(-) diff --git a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs index b1d5f0c7feda..e230a4deefca 100644 --- a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs +++ b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs @@ -1,7 +1,6 @@ -use swc_atoms::JsWord; -use swc_common::{collections::AHashMap, errors::HANDLER, Span}; +use swc_common::errors::HANDLER; use swc_ecma_ast::*; -use swc_ecma_utils::find_pat_ids; +use swc_ecma_utils::for_each_binding_ident; use swc_ecma_visit::{noop_visit_type, Visit, VisitWith}; use crate::rule::{visitor_rule, Rule}; @@ -13,54 +12,60 @@ pub fn no_dupe_args() -> Box { #[derive(Debug, Default)] struct NoDupeArgs {} -impl NoDupeArgs { - fn check(&self, param_list: Vec<(JsWord, Span)>) { - let mut variables_map = AHashMap::::default(); +/// This has time complexity of O(n^2), but it's fine as the number of paramters +/// is usually small. +macro_rules! check { + ($node:expr) => {{ + let mut i1 = 0; + for_each_binding_ident($node, |id1| { + i1 += 1; - param_list.into_iter().for_each(|(js_word, span)| { - if let Some(old_span) = variables_map.insert(js_word.clone(), span) { - HANDLER.with(|handler| { - handler - .struct_span_err( - span, - &format!( - "the name `{}` is bound more than once in this parameter list", - js_word - ), - ) - .span_label(old_span, "previous definition here".to_string()) - .span_label(span, &"used as parameter more than once".to_string()) - .emit(); - }); - } - }); - } + let mut i2 = 0; + for_each_binding_ident($node, |id2| { + i2 += 1; + + if i1 == i2 { + return; + } + + if id1.span.ctxt == id2.span.ctxt && id1.sym == id2.sym { + HANDLER.with(|handler| { + handler + .struct_span_err( + id2.span, + &format!( + "the name `{}` is bound more than once in this parameter list", + id1.sym + ), + ) + .span_label(id1.span, "previous definition here".to_string()) + .span_label(id2.span, &"used as parameter more than once".to_string()) + .emit(); + }); + } + }) + }) + }}; } impl Visit for NoDupeArgs { noop_visit_type!(); fn visit_function(&mut self, f: &Function) { - let variables: Vec<(JsWord, Span)> = find_pat_ids(&f.params); - - self.check(variables); + check!(&f.params); f.visit_children_with(self); } - fn visit_arrow_expr(&mut self, arrow_fn: &ArrowExpr) { - let variables: Vec<(JsWord, Span)> = find_pat_ids(&arrow_fn.params); + fn visit_arrow_expr(&mut self, f: &ArrowExpr) { + check!(&f.params); - self.check(variables); - - arrow_fn.visit_children_with(self); + f.visit_children_with(self); } - fn visit_constructor(&mut self, n: &Constructor) { - let variables: Vec<(JsWord, Span)> = find_pat_ids(&n.params); + fn visit_constructor(&mut self, f: &Constructor) { + check!(&f.params); - self.check(variables); - - n.visit_children_with(self); + f.visit_children_with(self); } } From d0688775ea437f261bc14b62797f008c1171b097 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 12 Jun 2024 16:32:21 +0900 Subject: [PATCH 03/13] fix cond --- crates/swc_ecma_lints/src/rules/no_dupe_args.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs index e230a4deefca..21fd6f30273f 100644 --- a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs +++ b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs @@ -24,7 +24,7 @@ macro_rules! check { for_each_binding_ident($node, |id2| { i2 += 1; - if i1 == i2 { + if i1 >= i2 { return; } From 7ecba82057d42a7b60225f2fd98d64684518bda9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 12 Jun 2024 16:34:36 +0900 Subject: [PATCH 04/13] fix visitor --- crates/swc_ecma_utils/src/lib.rs | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/crates/swc_ecma_utils/src/lib.rs b/crates/swc_ecma_utils/src/lib.rs index 2336565fcab5..a88265d68ca6 100644 --- a/crates/swc_ecma_utils/src/lib.rs +++ b/crates/swc_ecma_utils/src/lib.rs @@ -2407,7 +2407,8 @@ where op: F, } -/// Finds all **binding** idents of `node`. +/// Finds all **binding** idents of `node`. **Any nested identifiers in +/// expressions are ignored**. pub fn for_each_binding_ident(node: &T, op: F) where T: VisitWith>, @@ -2426,12 +2427,9 @@ where /// No-op (we don't care about expressions) fn visit_expr(&mut self, _: &Expr) {} - fn visit_ident(&mut self, i: &Ident) { + fn visit_binding_ident(&mut self, i: &BindingIdent) { (self.op)(i); } - - /// No-op (we don't care about expressions) - fn visit_prop_name(&mut self, _: &PropName) {} } pub fn is_valid_ident(s: &JsWord) -> bool { From 1065e2b3fb12636874aad8493d5f9c64f6adbf54 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 12 Jun 2024 16:36:23 +0900 Subject: [PATCH 05/13] Fix regression --- crates/swc_ecma_lints/src/rules/no_dupe_args.rs | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs index 21fd6f30273f..18a34f57e3ab 100644 --- a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs +++ b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs @@ -16,6 +16,9 @@ struct NoDupeArgs {} /// is usually small. macro_rules! check { ($node:expr) => {{ + // This allocates only if there are duplicate parameters. + let mut done = vec![]; + let mut i1 = 0; for_each_binding_ident($node, |id1| { i1 += 1; @@ -24,10 +27,12 @@ macro_rules! check { for_each_binding_ident($node, |id2| { i2 += 1; - if i1 >= i2 { + if i1 >= i2 || done.contains(&i1) { return; } + done.push(i1); + if id1.span.ctxt == id2.span.ctxt && id1.sym == id2.sym { HANDLER.with(|handler| { handler From c0f0427711e018430cf424bc06d52b3ee24a61f4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 12 Jun 2024 16:49:09 +0900 Subject: [PATCH 06/13] fix time --- crates/swc_ecma_lints/src/rules/no_dupe_args.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs index 18a34f57e3ab..2c0fc0a6c9ee 100644 --- a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs +++ b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs @@ -31,9 +31,9 @@ macro_rules! check { return; } - done.push(i1); - if id1.span.ctxt == id2.span.ctxt && id1.sym == id2.sym { + done.push(i1); + HANDLER.with(|handler| { handler .struct_span_err( From 490b991b9d2d496d962bda9f3ee60d93a55e17a6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 12 Jun 2024 17:03:51 +0900 Subject: [PATCH 07/13] Comment --- crates/swc_ecma_lints/src/rules/no_dupe_args.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs index 2c0fc0a6c9ee..4b3586f84f0a 100644 --- a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs +++ b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs @@ -16,7 +16,9 @@ struct NoDupeArgs {} /// is usually small. macro_rules! check { ($node:expr) => {{ - // This allocates only if there are duplicate parameters. + // This vector allocates only if there are duplicate parameters. + // This is used to handle the case where the same parameter is used 3 or more + // times. let mut done = vec![]; let mut i1 = 0; From 36f59bafe04e95388dea4f14bba4219297065f20 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 12 Jun 2024 17:08:41 +0900 Subject: [PATCH 08/13] Detect too many identifiers --- crates/swc_ecma_lints/src/rules/no_dupe_args.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs index 4b3586f84f0a..b99f0865192d 100644 --- a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs +++ b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs @@ -21,6 +21,8 @@ macro_rules! check { // times. let mut done = vec![]; + let mut hash_mode = false; + let mut i1 = 0; for_each_binding_ident($node, |id1| { i1 += 1; @@ -29,6 +31,15 @@ macro_rules! check { for_each_binding_ident($node, |id2| { i2 += 1; + if hash_mode { + return; + } else if i2 >= 100 { + // While iterating for the first `id1`, we detect that there are more than 100 + // identifiers. We switch to hash mode. + hash_mode = true; + return; + } + if i1 >= i2 || done.contains(&i1) { return; } From 37efe9b3851d92a8c3267ff4aa5cddba04162fd5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 12 Jun 2024 17:17:56 +0900 Subject: [PATCH 09/13] Prepare hash mode --- .../swc_ecma_lints/src/rules/no_dupe_args.rs | 82 +++++++++++-------- 1 file changed, 46 insertions(+), 36 deletions(-) diff --git a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs index b99f0865192d..497a6dee2273 100644 --- a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs +++ b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs @@ -1,4 +1,4 @@ -use swc_common::errors::HANDLER; +use swc_common::{collections::AHashMap, errors::HANDLER}; use swc_ecma_ast::*; use swc_ecma_utils::for_each_binding_ident; use swc_ecma_visit::{noop_visit_type, Visit, VisitWith}; @@ -12,6 +12,22 @@ pub fn no_dupe_args() -> Box { #[derive(Debug, Default)] struct NoDupeArgs {} +fn error(first: &Ident, second: &Ident) { + HANDLER.with(|handler| { + handler + .struct_span_err( + second.span, + &format!( + "the name `{}` is bound more than once in this parameter list", + first.sym + ), + ) + .span_label(first.span, "previous definition here".to_string()) + .span_label(second.span, &"used as parameter more than once".to_string()) + .emit(); + }); +} + /// This has time complexity of O(n^2), but it's fine as the number of paramters /// is usually small. macro_rules! check { @@ -22,46 +38,40 @@ macro_rules! check { let mut done = vec![]; let mut hash_mode = false; + // An empty hashmap does not allocate. + let mut map = AHashMap::default(); let mut i1 = 0; for_each_binding_ident($node, |id1| { i1 += 1; - let mut i2 = 0; - for_each_binding_ident($node, |id2| { - i2 += 1; - - if hash_mode { - return; - } else if i2 >= 100 { - // While iterating for the first `id1`, we detect that there are more than 100 - // identifiers. We switch to hash mode. - hash_mode = true; - return; - } - - if i1 >= i2 || done.contains(&i1) { - return; - } - - if id1.span.ctxt == id2.span.ctxt && id1.sym == id2.sym { - done.push(i1); - - HANDLER.with(|handler| { - handler - .struct_span_err( - id2.span, - &format!( - "the name `{}` is bound more than once in this parameter list", - id1.sym - ), - ) - .span_label(id1.span, "previous definition here".to_string()) - .span_label(id2.span, &"used as parameter more than once".to_string()) - .emit(); - }); - } - }) + if !hash_mode { + let mut i2 = 0; + for_each_binding_ident($node, |id2| { + i2 += 1; + + if hash_mode { + return; + } else if i2 >= 100 { + // While iterating for the first `id1`, we detect that there are more than + // 100 identifiers. We switch to hash mode. + hash_mode = true; + } + + if i1 >= i2 || done.contains(&i1) { + return; + } + + if id1.span.ctxt == id2.span.ctxt && id1.sym == id2.sym { + done.push(i1); + + error(id2, id1); + } + }); + } else { + // We finished checking for the first `id1`. We switch to hash + // mode. + } }) }}; } From e21a74a9ad63c856e6ec62ea2d355ee0c07af9d1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 12 Jun 2024 17:23:12 +0900 Subject: [PATCH 10/13] hash mode --- .../swc_ecma_lints/src/rules/no_dupe_args.rs | 28 ++++++++++++++----- 1 file changed, 21 insertions(+), 7 deletions(-) diff --git a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs index 497a6dee2273..178a5a23afa7 100644 --- a/crates/swc_ecma_lints/src/rules/no_dupe_args.rs +++ b/crates/swc_ecma_lints/src/rules/no_dupe_args.rs @@ -1,3 +1,5 @@ +use std::collections::hash_map::Entry; + use swc_common::{collections::AHashMap, errors::HANDLER}; use swc_ecma_ast::*; use swc_ecma_utils::for_each_binding_ident; @@ -38,8 +40,6 @@ macro_rules! check { let mut done = vec![]; let mut hash_mode = false; - // An empty hashmap does not allocate. - let mut map = AHashMap::default(); let mut i1 = 0; for_each_binding_ident($node, |id1| { @@ -65,14 +65,28 @@ macro_rules! check { if id1.span.ctxt == id2.span.ctxt && id1.sym == id2.sym { done.push(i1); - error(id2, id1); + error(id1, id2); } }); - } else { - // We finished checking for the first `id1`. We switch to hash - // mode. } - }) + }); + + if hash_mode { + let mut map = AHashMap::default(); + + for_each_binding_ident($node, |id| { + // + match map.entry((id.sym.clone(), id.span.ctxt)) { + Entry::Occupied(v) => { + error(v.get(), id); + } + + Entry::Vacant(v) => { + v.insert(id.clone()); + } + } + }); + } }}; } From e58e03d875be770aa348608fe2073bd41cb52b20 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 12 Jun 2024 17:30:09 +0900 Subject: [PATCH 11/13] Add a test --- .../tests/errors/lints/no-dupe-args/hash-mode/input.js | 9 +++++++++ 1 file changed, 9 insertions(+) create mode 100644 crates/swc/tests/errors/lints/no-dupe-args/hash-mode/input.js diff --git a/crates/swc/tests/errors/lints/no-dupe-args/hash-mode/input.js b/crates/swc/tests/errors/lints/no-dupe-args/hash-mode/input.js new file mode 100644 index 000000000000..40254a35bc86 --- /dev/null +++ b/crates/swc/tests/errors/lints/no-dupe-args/hash-mode/input.js @@ -0,0 +1,9 @@ +function foo( + [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + +} From e80b477d82ed1c26a9e417f090d2182168f9695e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 12 Jun 2024 17:31:07 +0900 Subject: [PATCH 12/13] fixup --- crates/swc/tests/errors/lints/no-dupe-args/hash-mode/input.js | 1 + 1 file changed, 1 insertion(+) diff --git a/crates/swc/tests/errors/lints/no-dupe-args/hash-mode/input.js b/crates/swc/tests/errors/lints/no-dupe-args/hash-mode/input.js index 40254a35bc86..381b9706d408 100644 --- a/crates/swc/tests/errors/lints/no-dupe-args/hash-mode/input.js +++ b/crates/swc/tests/errors/lints/no-dupe-args/hash-mode/input.js @@ -3,6 +3,7 @@ function foo( [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { From 58c0b0dc134e418f086504844689c98a03360bce Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=EA=B0=95=EB=8F=99=EC=9C=A4=20=28Donny=29?= Date: Wed, 12 Jun 2024 17:31:12 +0900 Subject: [PATCH 13/13] Update test refs --- .../no-dupe-args/hash-mode/output.swc-stderr | 680 ++++++++++++++++++ 1 file changed, 680 insertions(+) create mode 100644 crates/swc/tests/errors/lints/no-dupe-args/hash-mode/output.swc-stderr diff --git a/crates/swc/tests/errors/lints/no-dupe-args/hash-mode/output.swc-stderr b/crates/swc/tests/errors/lints/no-dupe-args/hash-mode/output.swc-stderr new file mode 100644 index 000000000000..444f93f8419c --- /dev/null +++ b/crates/swc/tests/errors/lints/no-dupe-args/hash-mode/output.swc-stderr @@ -0,0 +1,680 @@ + + x the name `a0` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `a1` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `a2` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `a3` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `a4` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `a5` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `a6` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `a7` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `a8` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `a9` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `b0` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `b1` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `b2` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `b3` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `b4` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `b5` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `b6` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `b7` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `b8` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `b9` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- used as parameter more than once + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + `---- + + x the name `a0` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `a1` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `a2` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `a3` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `a4` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `a5` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `a6` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `a7` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `a8` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `a9` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `b0` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `b1` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `b2` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `b3` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `b4` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `b5` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `b6` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `b7` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `b8` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `---- + + x the name `b9` is bound more than once in this parameter list + ,-[1:1] + 1 | function foo( + 2 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + : ^| + : `-- previous definition here + 3 | [c0, c1, c2, c3, c4, c5, c6, c7, c8, c9], [d0, d1, d2, d3, d4, d5, d6, d7, d8, d9], + 4 | [e0, e1, e2, e3, e4, e5, e6, e7, e8, e9], [f0, f1, f2, f3, f4, f5, f6, f7, f8, f9], + 5 | [g0, g1, g2, g3, g4, g5, g6, g7, g8, g9], [h0, h1, h2, h3, h4, h5, h6, h7, h8, h9], + 6 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9], + 7 | [i0, i1, i2, i3, i4, i5, i6, i7, i8, i9], [j0, j1, j2, j3, j4, j5, j6, j7, j8, j9], + 8 | [a0, a1, a2, a3, a4, a5, a6, a7, a8, a9], [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9],) { + : ^| + : `-- used as parameter more than once + 9 | + 10 | } + `----