Rest patterns should get the correct type about stc

[TrickyPi]

Hi @kdy1, i'd like to fix it 😊 .

[kdy1]

Thank you!

[TrickyPi]

Hi @kdy1

I created a minimal test for debugging

the file link

and the error information is

I found that the error happens here

stc/crates/stc_ts_file_analyzer/src/analyzer/assign/mod.rs

Lines 375 to 413 in 2ab93ad

	pub(crate) fn assign_with_opts(&mut self, data: &mut AssignData, mut opts: AssignOpts, left: &Type, right: &Type) -> VResult<()> {
	if self.is_builtin {
	return Ok(());
	}
	opts.is_params_of_method_definition = false;
	left.assert_valid();
	right.assert_valid();
	let _stack = stack::track(opts.span)?;
	// if cfg!(debug_assertions) && span.is_dummy() {
	// print_backtrace();
	// debug_assert!(!span.is_dummy());
	// }
	// self.verify_before_assign("lhs", left);
	// self.verify_before_assign("rhs", right);
	let res = self.assign_inner(data, left, right, opts);
	match res {
	Err(Error::Errors { errors, .. }) if errors.is_empty() => return Ok(()),
	_ => {}
	}
	res.convert_err(|err| match err {
	Error::AssignFailed { .. }
	| Error::Errors { .. }
	| Error::Unimplemented { .. }
	| Error::TupleAssignError { .. }
	| Error::ObjectAssignFailed { .. } => err,
	_ => Error::AssignFailed {
	span: opts.span,
	left: box left.clone(),
	right: box right.clone(),
	right_ident: opts.right_ident_span,
	cause: vec![err],
	},
	})

Do you have any advice? Seems the bug isn't here

stc/crates/stc_ts_file_analyzer/src/analyzer/scope/vars.rs

Lines 292 to 326 in 2ab93ad

	RPat::Rest(elem) => {
	// Rest element is special.
	let type_for_rest_arg = match ty {
	Some(ty) => self
	.get_rest_elements(Some(span), Cow::Owned(ty), idx)
	.context(
	"tried to get lefting elements of an iterator to declare variables using a rest \
	pattern",
	)
	.map(Cow::into_owned)
	.report(&mut self.storage),
	None => None,
	}
	.freezed();
	let default = match default {
	Some(ty) => self
	.get_rest_elements(Some(span), Cow::Owned(ty), idx)
	.context(
	"tried to get lefting elements of an iterator to declare variables using a rest \
	pattern",
	)
	.map(Cow::into_owned)
	.report(&mut self.storage),
	None => None,
	}
	.freezed();
	self.add_vars(&elem.arg, type_for_rest_arg, None, default, opts)
	.context("tried to declare lefting elements to the arugment of a rest pattern")
	.report(&mut self.storage);
	break;
	}
	_ => {}
	}

BTW, opts.use_iterator_for_array is true

stc/crates/stc_ts_file_analyzer/src/analyzer/scope/vars.rs

Lines 210 to 372 in 2ab93ad

	if opts.use_iterator_for_array {
	// Handle tuple
	//
	// const [a , setA] = useState();
	//
	let ty = ty.map(|ty| {
	self.get_iterator(
	span,
	Cow::Owned(ty),
	GetIteratorOpts {
	disallow_str: true,
	..Default::default()
	},
	)
	.context("tried to convert a type to an iterator to assign with an array pattern.")
	.unwrap_or_else(|err| {
	self.storage.report(err);
	Cow::Owned(Type::any(span, Default::default()))
	})
	});
	let default = default.map(|ty| {
	self.get_iterator(
	span,
	Cow::Owned(ty),
	GetIteratorOpts {
	disallow_str: true,
	..Default::default()
	},
	)
	.context("tried to convert a type to an iterator to assign with an array pattern (default value)")
	.unwrap_or_else(|err| {
	self.storage.report(err);
	Cow::Owned(Type::any(span, Default::default()))
	})
	});
	for (idx, elem) in arr.elems.iter().enumerate() {
	if let Some(elem) = elem {
	let elem_ty = ty
	.as_ref()
	.try_map(|ty| -> VResult<_> {
	Ok(self
	.get_element_from_iterator(span, Cow::Borrowed(&ty), idx)
	.with_context(|| {
	format!(
	"tried to get the type of {}th element from iterator to declare vars with an array pattern",
	idx
	)
	})?
	.into_owned())
	})?
	.freezed();
	let default_elem_ty = default
	.as_ref()
	.and_then(|ty| {
	self.get_element_from_iterator(span, Cow::Borrowed(&ty), idx)
	.with_context(|| {
	format!(
	"tried to get the type of {}th element from iterator to declare vars with an array \
	pattern (default value)",
	idx
	)
	})
	.ok()
	})
	.map(Cow::into_owned)
	.freezed();
	// TODO(kdy1): actual_ty
	self.add_vars(elem, elem_ty, None, default_elem_ty, opts)?;
	}
	}
	Ok(())
	} else {
	for (idx, elem) in arr.elems.iter().enumerate() {
	match elem {
	Some(elem) => {
	match elem {
	RPat::Rest(elem) => {
	// Rest element is special.
	let type_for_rest_arg = match ty {
	Some(ty) => self
	.get_rest_elements(Some(span), Cow::Owned(ty), idx)
	.context(
	"tried to get lefting elements of an iterator to declare variables using a rest \
	pattern",
	)
	.map(Cow::into_owned)
	.report(&mut self.storage),
	None => None,
	}
	.freezed();
	let default = match default {
	Some(ty) => self
	.get_rest_elements(Some(span), Cow::Owned(ty), idx)
	.context(
	"tried to get lefting elements of an iterator to declare variables using a rest \
	pattern",
	)
	.map(Cow::into_owned)
	.report(&mut self.storage),
	None => None,
	}
	.freezed();
	self.add_vars(&elem.arg, type_for_rest_arg, None, default, opts)
	.context("tried to declare lefting elements to the arugment of a rest pattern")
	.report(&mut self.storage);
	break;
	}
	_ => {}
	}
	let elem_ty = match &ty {
	Some(ty) => self
	.access_property(
	elem.span(),
	&ty,
	&Key::Num(RNumber {
	span: elem.span(),
	value: idx as f64,
	}),
	TypeOfMode::RValue,
	IdCtx::Var,
	Default::default(),
	)
	.context("tried to access property to declare variables using an array pattern")
	.report(&mut self.storage),
	None => None,
	}
	.freezed();
	let default = match &default {
	Some(ty) => self
	.access_property(
	elem.span(),
	&ty,
	&Key::Num(RNumber {
	span: elem.span(),
	value: idx as f64,
	}),
	TypeOfMode::RValue,
	IdCtx::Var,
	Default::default(),
	)
	.context("tried to access property to declare variables using an array pattern")
	.report(&mut self.storage),
	None => None,
	}
	.freezed();
	// TODO(kdy1): actual_ty
	self.add_vars(elem, elem_ty, None, default, opts).report(&mut self.storage);
	}
	// Skip
	None => {}
	}
	}

[kdy1]

I guess that get_rest_elements is returning the wrong value.

And there's a TODO for it

stc/crates/stc_ts_file_analyzer/src/analyzer/expr/array.rs

Lines 543 to 551 in 2ab93ad

	iterator.make_clone_cheap();
	let ty = iterator.into_owned().expect_tuple();
	// TODO: Handle [Type::Rest]
	return Ok(Cow::Owned(Type::Tuple(Tuple {
	elems: ty.elems.into_iter().skip(start_index).collect(),
	..ty
	})));

[TrickyPi]

Thanks for your reply.
Yes, I knew this TODO exists, but I added a "println!" before calling get_rest_elements and it wasn't called.

[kdy1]

If so, I think you can add some debug prints to scope/vars.rs in the body of the issue

[TrickyPi]

yeah, i added a debug print to ouput the value of opts.use_iterator_for_array, this value is true.

[kdy1]

I think you should print types instead. There's dump_type_as_string which can be used to print readable form of types

[TrickyPi]

Ok, i get it.

[kdy1]

@TrickyPi Are you working on it? Feel free to tell me if you want me to take it (or unassign)

[TrickyPi]

I'v been busy with other work lately, and this issue seems hard to me(LOL),so I'm happy you can take it and really appericate your help during this time.