use super::{DiagnosticMessage};
impl Clone for DiagnosticMessage {
fn clone(&self) -> Self {
if self.is_fraction_after_numeric() {
return Self::new_fraction_after_numeric();
}
if self.is_no_digits_after_dot() {
return Self::new_no_digits_after_dot();
}
if self.is_unknown_type_of_percent_string() {
return Self::new_unknown_type_of_percent_string();
}
if self.is_numeric_literal_without_digits() {
return Self::new_numeric_literal_without_digits();
}
if self.is_unterminated_list() {
return Self::new_unterminated_list();
}
if self.is_unterminated_regexp() {
return Self::new_unterminated_regexp();
}
if self.is_unterminated_string() {
return Self::new_unterminated_string();
}
if self.is_unterminated_quoted_string() {
return Self::new_unterminated_quoted_string();
}
if self.is_invalid_unicode_escape() {
return Self::new_invalid_unicode_escape();
}
if self.is_too_large_unicode_codepoint() {
return Self::new_too_large_unicode_codepoint();
}
if self.is_invalid_unicode_codepoint() {
return Self::new_invalid_unicode_codepoint();
}
if self.is_multiple_codepoint_at_single_char() {
return Self::new_multiple_codepoint_at_single_char();
}
if self.is_invalid_escape_character() {
return Self::new_invalid_escape_character();
}
if self.is_invalid_hex_escape() {
return Self::new_invalid_hex_escape();
}
if let Some(variant) = self.as_unterminated_heredoc() {
return Self::new_unterminated_heredoc(variant.get_heredoc_id().clone(), );
}
if self.is_unterminated_heredoc_id() {
return Self::new_unterminated_heredoc_id();
}
if self.is_slash_r_at_middle_of_line() {
return Self::new_slash_r_at_middle_of_line();
}
if self.is_d_star_interpreted_as_arg_prefix() {
return Self::new_d_star_interpreted_as_arg_prefix();
}
if self.is_star_interpreted_as_arg_prefix() {
return Self::new_star_interpreted_as_arg_prefix();
}
if self.is_ampersand_interpreted_as_arg_prefix() {
return Self::new_ampersand_interpreted_as_arg_prefix();
}
if self.is_triple_dot_at_eol() {
return Self::new_triple_dot_at_eol();
}
if self.is_parentheses_iterpreted_as_arglist() {
return Self::new_parentheses_iterpreted_as_arglist();
}
if let Some(variant) = self.as_ambiguous_first_argument() {
return Self::new_ambiguous_first_argument(variant.get_operator().clone(), );
}
if let Some(variant) = self.as_ambiguous_operator() {
return Self::new_ambiguous_operator(variant.get_operator().clone(), variant.get_interpreted_as().clone(), );
}
if let Some(variant) = self.as_invalid_character_syntax() {
return Self::new_invalid_character_syntax(variant.get_suggestion().clone(), );
}
if self.is_invalid_octal_digit() {
return Self::new_invalid_octal_digit();
}
if let Some(variant) = self.as_trailing_char_in_number() {
return Self::new_trailing_char_in_number(variant.get_c().clone(), );
}
if self.is_embedded_document_meets_eof() {
return Self::new_embedded_document_meets_eof();
}
if let Some(variant) = self.as_invalid_char() {
return Self::new_invalid_char(variant.get_c().clone(), );
}
if self.is_incomplete_character_syntax() {
return Self::new_incomplete_character_syntax();
}
if self.is_gvar_without_id() {
return Self::new_gvar_without_id();
}
if let Some(variant) = self.as_invalid_gvar_name() {
return Self::new_invalid_gvar_name(variant.get_c().clone(), );
}
if self.is_ivar_without_id() {
return Self::new_ivar_without_id();
}
if let Some(variant) = self.as_invalid_ivar_name() {
return Self::new_invalid_ivar_name(variant.get_c().clone(), );
}
if self.is_cvar_without_id() {
return Self::new_cvar_without_id();
}
if let Some(variant) = self.as_invalid_cvar_name() {
return Self::new_invalid_cvar_name(variant.get_c().clone(), );
}
if let Some(variant) = self.as_unknown_regex_options() {
return Self::new_unknown_regex_options(variant.get_options().clone(), );
}
if self.is_unterminated_unicode_escape() {
return Self::new_unterminated_unicode_escape();
}
if let Some(variant) = self.as_encoding_error() {
return Self::new_encoding_error(variant.get_error().clone(), );
}
if self.is_invalid_multibyte_char() {
return Self::new_invalid_multibyte_char();
}
if let Some(variant) = self.as_ambiguous_ternary_operator() {
return Self::new_ambiguous_ternary_operator(variant.get_condition().clone(), );
}
if self.is_ambiguous_regexp() {
return Self::new_ambiguous_regexp();
}
if self.is_else_without_rescue() {
return Self::new_else_without_rescue();
}
if self.is_begin_not_at_top_level() {
return Self::new_begin_not_at_top_level();
}
if self.is_alias_nth_ref() {
return Self::new_alias_nth_ref();
}
if self.is_csend_inside_masgn() {
return Self::new_csend_inside_masgn();
}
if self.is_class_or_module_name_must_be_constant() {
return Self::new_class_or_module_name_must_be_constant();
}
if self.is_endless_setter_definition() {
return Self::new_endless_setter_definition();
}
if let Some(variant) = self.as_unexpected_token() {
return Self::new_unexpected_token(variant.get_token_name().clone(), );
}
if self.is_class_definition_in_method_body() {
return Self::new_class_definition_in_method_body();
}
if self.is_module_definition_in_method_body() {
return Self::new_module_definition_in_method_body();
}
if self.is_invalid_return_in_class_or_module_body() {
return Self::new_invalid_return_in_class_or_module_body();
}
if self.is_const_argument() {
return Self::new_const_argument();
}
if self.is_ivar_argument() {
return Self::new_ivar_argument();
}
if self.is_gvar_argument() {
return Self::new_gvar_argument();
}
if self.is_cvar_argument() {
return Self::new_cvar_argument();
}
if let Some(variant) = self.as_no_such_local_variable() {
return Self::new_no_such_local_variable(variant.get_var_name().clone(), );
}
if self.is_ordinary_param_defined() {
return Self::new_ordinary_param_defined();
}
if self.is_numparam_used() {
return Self::new_numparam_used();
}
if let Some(variant) = self.as_tok_at_eol_without_expression() {
return Self::new_tok_at_eol_without_expression(variant.get_token_name().clone(), );
}
if self.is_end_in_method() {
return Self::new_end_in_method();
}
if let Some(variant) = self.as_comparison_after_comparison() {
return Self::new_comparison_after_comparison(variant.get_comparison().clone(), );
}
if let Some(variant) = self.as_circular_argument_reference() {
return Self::new_circular_argument_reference(variant.get_arg_name().clone(), );
}
if self.is_dynamic_constant_assignment() {
return Self::new_dynamic_constant_assignment();
}
if self.is_cant_assign_to_self() {
return Self::new_cant_assign_to_self();
}
if self.is_cant_assign_to_nil() {
return Self::new_cant_assign_to_nil();
}
if self.is_cant_assign_to_true() {
return Self::new_cant_assign_to_true();
}
if self.is_cant_assign_to_false() {
return Self::new_cant_assign_to_false();
}
if self.is_cant_assign_to_file() {
return Self::new_cant_assign_to_file();
}
if self.is_cant_assign_to_line() {
return Self::new_cant_assign_to_line();
}
if self.is_cant_assign_to_encoding() {
return Self::new_cant_assign_to_encoding();
}
if let Some(variant) = self.as_cant_assign_to_numparam() {
return Self::new_cant_assign_to_numparam(variant.get_numparam().clone(), );
}
if let Some(variant) = self.as_cant_set_variable() {
return Self::new_cant_set_variable(variant.get_var_name().clone(), );
}
if self.is_block_given_to_yield() {
return Self::new_block_given_to_yield();
}
if self.is_block_and_block_arg_given() {
return Self::new_block_and_block_arg_given();
}
if self.is_symbol_literal_with_interpolation() {
return Self::new_symbol_literal_with_interpolation();
}
if let Some(variant) = self.as_reserved_for_numparam() {
return Self::new_reserved_for_numparam(variant.get_numparam().clone(), );
}
if self.is_key_must_be_valid_as_local_variable() {
return Self::new_key_must_be_valid_as_local_variable();
}
if self.is_duplicate_variable_name() {
return Self::new_duplicate_variable_name();
}
if self.is_duplicate_key_name() {
return Self::new_duplicate_key_name();
}
if self.is_singleton_literal() {
return Self::new_singleton_literal();
}
if let Some(variant) = self.as_nth_ref_is_too_big() {
return Self::new_nth_ref_is_too_big(variant.get_nth_ref().clone(), );
}
if self.is_duplicated_argument_name() {
return Self::new_duplicated_argument_name();
}
if let Some(variant) = self.as_regex_error() {
return Self::new_regex_error(variant.get_error().clone(), );
}
if let Some(variant) = self.as_invalid_symbol() {
return Self::new_invalid_symbol(variant.get_symbol().clone(), );
}
if self.is_void_value_expression() {
return Self::new_void_value_expression();
}
panic!("unrecognized diagnostic message type")
}
}