diff --git a/src/ast.rs b/src/ast.rs index 91921613c..c4061864a 100644 --- a/src/ast.rs +++ b/src/ast.rs @@ -1267,7 +1267,7 @@ fn can_be_parsed(pop: &mut Populator<'_>) -> bool { || (token.typ == ParseTokenType::string && !matches!( token.keyword, - ParseKeyword::kw_case | ParseKeyword::kw_end | ParseKeyword::kw_else + ParseKeyword::Case | ParseKeyword::End | ParseKeyword::Else )) } } @@ -1504,8 +1504,8 @@ fn as_mut_elseif_clause(&mut self) -> Option<&mut ElseifClause> { } impl CheckParse for ElseifClause { fn can_be_parsed(pop: &mut Populator<'_>) -> bool { - pop.peek_token(0).keyword == ParseKeyword::kw_else - && pop.peek_token(1).keyword == ParseKeyword::kw_if + pop.peek_token(0).keyword == ParseKeyword::Else + && pop.peek_token(1).keyword == ParseKeyword::If } } @@ -1548,7 +1548,7 @@ fn as_mut_else_clause(&mut self) -> Option<&mut ElseClause> { } impl CheckParse for ElseClause { fn can_be_parsed(pop: &mut Populator<'_>) -> bool { - pop.peek_token(0).keyword == ParseKeyword::kw_else + pop.peek_token(0).keyword == ParseKeyword::Else } } @@ -1615,7 +1615,7 @@ fn as_mut_case_item(&mut self) -> Option<&mut CaseItem> { } impl CheckParse for CaseItem { fn can_be_parsed(pop: &mut Populator<'_>) -> bool { - pop.peek_token(0).keyword == ParseKeyword::kw_case + pop.peek_token(0).keyword == ParseKeyword::Case } } @@ -1814,7 +1814,7 @@ fn as_mut_andor_job(&mut self) -> Option<&mut AndorJob> { impl CheckParse for AndorJob { fn can_be_parsed(pop: &mut Populator<'_>) -> bool { let keyword = pop.peek_token(0).keyword; - if !matches!(keyword, ParseKeyword::kw_and | ParseKeyword::kw_or) { + if !matches!(keyword, ParseKeyword::And | ParseKeyword::Or) { return false; } // Check that the argument to and/or is a string that's not help. Otherwise @@ -2021,27 +2021,27 @@ fn can_be_parsed(pop: &mut Populator<'_>) -> bool { define_token_node!(TokenRightBrace, right_brace); define_token_node!(TokenRedirection, redirection); -define_keyword_node!(DecoratedStatementDecorator, kw_command, kw_builtin, kw_exec); -define_keyword_node!(JobConjunctionDecorator, kw_and, kw_or); -define_keyword_node!(KeywordBegin, kw_begin); -define_keyword_node!(KeywordCase, kw_case); -define_keyword_node!(KeywordElse, kw_else); -define_keyword_node!(KeywordEnd, kw_end); -define_keyword_node!(KeywordFor, kw_for); -define_keyword_node!(KeywordFunction, kw_function); -define_keyword_node!(KeywordIf, kw_if); -define_keyword_node!(KeywordIn, kw_in); -define_keyword_node!(KeywordNot, kw_not, kw_exclam); -define_keyword_node!(KeywordSwitch, kw_switch); -define_keyword_node!(KeywordTime, kw_time); -define_keyword_node!(KeywordWhile, kw_while); +define_keyword_node!(DecoratedStatementDecorator, Command, Builtin, Exec); +define_keyword_node!(JobConjunctionDecorator, And, Or); +define_keyword_node!(KeywordBegin, Begin); +define_keyword_node!(KeywordCase, Case); +define_keyword_node!(KeywordElse, Else); +define_keyword_node!(KeywordEnd, End); +define_keyword_node!(KeywordFor, For); +define_keyword_node!(KeywordFunction, Function); +define_keyword_node!(KeywordIf, If); +define_keyword_node!(KeywordIn, In); +define_keyword_node!(KeywordNot, Not, Exclam); +define_keyword_node!(KeywordSwitch, Switch); +define_keyword_node!(KeywordTime, Time); +define_keyword_node!(KeywordWhile, While); impl CheckParse for JobConjunctionDecorator { fn can_be_parsed(pop: &mut Populator<'_>) -> bool { // This is for a job conjunction like `and stuff` // But if it's `and --help` then we treat it as an ordinary command. let keyword = pop.peek_token(0).keyword; - if !matches!(keyword, ParseKeyword::kw_and | ParseKeyword::kw_or) { + if !matches!(keyword, ParseKeyword::And | ParseKeyword::Or) { return false; } !pop.peek_token(1).is_help_argument @@ -2057,7 +2057,7 @@ fn can_be_parsed(pop: &mut Populator<'_>) -> bool { let keyword = pop.peek_token(0).keyword; if !matches!( keyword, - ParseKeyword::kw_command | ParseKeyword::kw_builtin | ParseKeyword::kw_exec + ParseKeyword::Command | ParseKeyword::Builtin | ParseKeyword::Exec ) { return false; } @@ -2070,7 +2070,7 @@ impl CheckParse for KeywordTime { fn can_be_parsed(pop: &mut Populator<'_>) -> bool { // Time keyword is only the time builtin if the next argument doesn't have a dash. let keyword = pop.peek_token(0).keyword; - if !matches!(keyword, ParseKeyword::kw_time) { + if !matches!(keyword, ParseKeyword::Time) { return false; } !pop.peek_token(1).is_dash_prefix_string() @@ -2085,9 +2085,9 @@ pub fn decoration(&self) -> StatementDecoration { }; let decorator: &dyn Keyword = decorator; match decorator.keyword() { - ParseKeyword::kw_command => StatementDecoration::command, - ParseKeyword::kw_builtin => StatementDecoration::builtin, - ParseKeyword::kw_exec => StatementDecoration::exec, + ParseKeyword::Command => StatementDecoration::command, + ParseKeyword::Builtin => StatementDecoration::builtin, + ParseKeyword::Exec => StatementDecoration::exec, _ => panic!("Unexpected keyword in statement decoration"), } } @@ -2614,7 +2614,7 @@ pub fn dump(&self, orig: &wstr) -> WString { WString::from_str("") } _ => { - token_type_user_presentable_description(n.token_type(), ParseKeyword::none) + token_type_user_presentable_description(n.token_type(), ParseKeyword::None) } }; result += &desc[..]; @@ -3064,7 +3064,7 @@ fn did_visit_fields_of<'a>(&'a mut self, node: &'a dyn NodeMut, flow: VisitResul if next_token.typ == ParseTokenType::string && matches!( next_token.keyword, - ParseKeyword::kw_case | ParseKeyword::kw_else | ParseKeyword::kw_end + ParseKeyword::Case | ParseKeyword::Else | ParseKeyword::End ) { self.consume_excess_token_generating_error(); @@ -3168,7 +3168,7 @@ fn token_types_user_presentable_description(types: &'static [ParseTokenType]) -> if !res.is_empty() { res += L!(" or "); } - res += &token_type_user_presentable_description(*typ, ParseKeyword::none)[..]; + res += &token_type_user_presentable_description(*typ, ParseKeyword::None)[..]; } res } @@ -3394,7 +3394,7 @@ fn consume_token_type(&mut self, typ: ParseTokenType) -> SourceRange { tok, ParseErrorCode::generic, "Expected %ls, but found %ls", - token_type_user_presentable_description(typ, ParseKeyword::none), + token_type_user_presentable_description(typ, ParseKeyword::None), tok.user_presentable_description() ); return SourceRange::new(0, 0); @@ -3419,7 +3419,7 @@ fn consume_excess_token_generating_error(&mut self) { tok, ParseErrorCode::generic, "Expected %ls, but found %ls", - token_type_user_presentable_description(ParseTokenType::string, ParseKeyword::none), + token_type_user_presentable_description(ParseTokenType::string, ParseKeyword::None), tok.user_presentable_description() ); return; @@ -3430,7 +3430,7 @@ fn consume_excess_token_generating_error(&mut self) { ParseTokenType::string => { // There are three keywords which end a job list. match tok.keyword { - ParseKeyword::kw_case => { + ParseKeyword::Case => { parse_error!( self, tok, @@ -3438,7 +3438,7 @@ fn consume_excess_token_generating_error(&mut self) { "'case' builtin not inside of switch block" ); } - ParseKeyword::kw_end => { + ParseKeyword::End => { parse_error!( self, tok, @@ -3446,7 +3446,7 @@ fn consume_excess_token_generating_error(&mut self) { "'end' outside of a block" ); } - ParseKeyword::kw_else => { + ParseKeyword::Else => { parse_error!( self, tok, @@ -3648,7 +3648,7 @@ fn new_decorated_statement(slf: &mut Populator<'_>) -> StatementVariant { "Expected %s, but found %ls", token_type_user_presentable_description( ParseTokenType::end, - ParseKeyword::none + ParseKeyword::None ), slf.peek_token(0).user_presentable_description() ); @@ -3706,11 +3706,11 @@ fn new_decorated_statement(slf: &mut Populator<'_>) -> StatementVariant { // If we are one of these, then look for specifically help arguments. Otherwise, if the next token // looks like an option (starts with a dash), then parse it as a decorated statement. let help_only_kws = [ - ParseKeyword::kw_begin, - ParseKeyword::kw_function, - ParseKeyword::kw_if, - ParseKeyword::kw_switch, - ParseKeyword::kw_while, + ParseKeyword::Begin, + ParseKeyword::Function, + ParseKeyword::If, + ParseKeyword::Switch, + ParseKeyword::While, ]; if if help_only_kws.contains(&self.peek_token(0).keyword) { self.peek_token(1).is_help_argument @@ -3722,8 +3722,8 @@ fn new_decorated_statement(slf: &mut Populator<'_>) -> StatementVariant { // Likewise if the next token doesn't look like an argument at all. This corresponds to // e.g. a "naked if". - let naked_invocation_invokes_help = ![ParseKeyword::kw_begin, ParseKeyword::kw_end] - .contains(&self.peek_token(0).keyword); + let naked_invocation_invokes_help = + ![ParseKeyword::Begin, ParseKeyword::End].contains(&self.peek_token(0).keyword); if naked_invocation_invokes_help && [ParseTokenType::end, ParseTokenType::terminate] .contains(&self.peek_token(1).typ) @@ -3733,26 +3733,26 @@ fn new_decorated_statement(slf: &mut Populator<'_>) -> StatementVariant { } match self.peek_token(0).keyword { - ParseKeyword::kw_not | ParseKeyword::kw_exclam => { + ParseKeyword::Not | ParseKeyword::Exclam => { let embedded = self.allocate_boxed_visit::(); StatementVariant::NotStatement(embedded) } - ParseKeyword::kw_for - | ParseKeyword::kw_while - | ParseKeyword::kw_function - | ParseKeyword::kw_begin => { + ParseKeyword::For + | ParseKeyword::While + | ParseKeyword::Function + | ParseKeyword::Begin => { let embedded = self.allocate_boxed_visit::(); StatementVariant::BlockStatement(embedded) } - ParseKeyword::kw_if => { + ParseKeyword::If => { let embedded = self.allocate_boxed_visit::(); StatementVariant::IfStatement(embedded) } - ParseKeyword::kw_switch => { + ParseKeyword::Switch => { let embedded = self.allocate_boxed_visit::(); StatementVariant::SwitchStatement(embedded) } - ParseKeyword::kw_end => { + ParseKeyword::End => { // 'end' is forbidden as a command. // For example, `if end` or `while end` will produce this error. // We still have to descend into the decorated statement because @@ -3774,19 +3774,19 @@ fn new_decorated_statement(slf: &mut Populator<'_>) -> StatementVariant { /// This must never return null. fn allocate_populate_block_header(&mut self) -> BlockStatementHeaderVariant { match self.peek_token(0).keyword { - ParseKeyword::kw_for => { + ParseKeyword::For => { let embedded = self.allocate_visit::(); BlockStatementHeaderVariant::ForHeader(embedded) } - ParseKeyword::kw_while => { + ParseKeyword::While => { let embedded = self.allocate_visit::(); BlockStatementHeaderVariant::WhileHeader(embedded) } - ParseKeyword::kw_function => { + ParseKeyword::Function => { let embedded = self.allocate_visit::(); BlockStatementHeaderVariant::FunctionHeader(embedded) } - ParseKeyword::kw_begin => { + ParseKeyword::Begin => { let embedded = self.allocate_visit::(); BlockStatementHeaderVariant::BeginHeader(embedded) } @@ -3863,7 +3863,7 @@ fn visit_variable_assignment(&mut self, varas: &mut VariableAssignment) { fn visit_job_continuation(&mut self, node: &mut JobContinuation) { // Special error handling to catch 'and' and 'or' in pipelines, like `true | and false`. - if [ParseKeyword::kw_and, ParseKeyword::kw_or].contains(&self.peek_token(1).keyword) { + if [ParseKeyword::And, ParseKeyword::Or].contains(&self.peek_token(1).keyword) { parse_error!( self, self.peek_token(1), @@ -3931,7 +3931,7 @@ fn visit_keyword(&mut self, keyword: &mut dyn Keyword) -> VisitResult { // Special error reporting for keyword_t. let allowed_keywords = keyword.allowed_keywords(); - if keyword.allowed_keywords() == [ParseKeyword::kw_end] { + if keyword.allowed_keywords() == [ParseKeyword::End] { return VisitResult::Break(MissingEndError { allowed_keywords, token: *self.peek_token(0), @@ -4121,7 +4121,7 @@ pub(crate) fn unescape_keyword(tok: TokenType, token: &wstr) -> Cow<'_, wstr> { Cow::Owned(unescape_string(token, UnescapeStringStyle::default()).unwrap_or_default()) } -/// Given a token, returns the keyword it matches, or ParseKeyword::none. +/// Given a token, returns the keyword it matches, or ParseKeyword::None. fn keyword_for_token(tok: TokenType, token: &wstr) -> ParseKeyword { ParseKeyword::from(&unescape_keyword(tok, token)[..]) } diff --git a/src/highlight/highlight.rs b/src/highlight/highlight.rs index 33092a4ae..12b8d3026 100644 --- a/src/highlight/highlight.rs +++ b/src/highlight/highlight.rs @@ -844,25 +844,25 @@ fn visit_children(&mut self, node: &dyn Node) { fn visit_keyword(&mut self, node: &dyn Keyword) { let mut role = HighlightRole::normal; match node.keyword() { - ParseKeyword::kw_begin - | ParseKeyword::kw_builtin - | ParseKeyword::kw_case - | ParseKeyword::kw_command - | ParseKeyword::kw_else - | ParseKeyword::kw_end - | ParseKeyword::kw_exec - | ParseKeyword::kw_for - | ParseKeyword::kw_function - | ParseKeyword::kw_if - | ParseKeyword::kw_in - | ParseKeyword::kw_switch - | ParseKeyword::kw_while => role = HighlightRole::keyword, - ParseKeyword::kw_and - | ParseKeyword::kw_or - | ParseKeyword::kw_not - | ParseKeyword::kw_exclam - | ParseKeyword::kw_time => role = HighlightRole::operat, - ParseKeyword::none => (), + ParseKeyword::Begin + | ParseKeyword::Builtin + | ParseKeyword::Case + | ParseKeyword::Command + | ParseKeyword::Else + | ParseKeyword::End + | ParseKeyword::Exec + | ParseKeyword::For + | ParseKeyword::Function + | ParseKeyword::If + | ParseKeyword::In + | ParseKeyword::Switch + | ParseKeyword::While => role = HighlightRole::keyword, + ParseKeyword::And + | ParseKeyword::Or + | ParseKeyword::Not + | ParseKeyword::Exclam + | ParseKeyword::Time => role = HighlightRole::operat, + ParseKeyword::None => (), }; self.color_node(node.leaf_as_node(), HighlightSpec::with_fg(role)); } diff --git a/src/parse_constants.rs b/src/parse_constants.rs index 46f9b8587..d9a669112 100644 --- a/src/parse_constants.rs +++ b/src/parse_constants.rs @@ -84,27 +84,27 @@ pub enum ParseTokenType { #[repr(u8)] #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum ParseKeyword { - // 'none' is not a keyword, it is a sentinel indicating nothing. - none, - - kw_and, - kw_begin, - kw_builtin, - kw_case, - kw_command, - kw_else, - kw_end, - kw_exclam, - kw_exec, - kw_for, - kw_function, - kw_if, - kw_in, - kw_not, - kw_or, - kw_switch, - kw_time, - kw_while, + // 'None' is not a keyword, it is a sentinel indicating nothing. + // Note it proves convenient to keep this as a value rather than using Option. + None, + And, + Begin, + Builtin, + Case, + Command, + Else, + End, + Exclam, + Exec, + For, + Function, + If, + In, + Not, + Or, + Switch, + Time, + While, } // Statement decorations like 'command' or 'exec'. @@ -224,7 +224,7 @@ pub fn to_wstr(self) -> &'static wstr { impl Default for ParseKeyword { fn default() -> Self { - ParseKeyword::none + ParseKeyword::None } } @@ -232,24 +232,24 @@ impl ParseKeyword { /// Return the keyword as a string. pub fn to_wstr(self) -> &'static wstr { match self { - ParseKeyword::kw_and => L!("and"), - ParseKeyword::kw_begin => L!("begin"), - ParseKeyword::kw_builtin => L!("builtin"), - ParseKeyword::kw_case => L!("case"), - ParseKeyword::kw_command => L!("command"), - ParseKeyword::kw_else => L!("else"), - ParseKeyword::kw_end => L!("end"), - ParseKeyword::kw_exclam => L!("!"), - ParseKeyword::kw_exec => L!("exec"), - ParseKeyword::kw_for => L!("for"), - ParseKeyword::kw_function => L!("function"), - ParseKeyword::kw_if => L!("if"), - ParseKeyword::kw_in => L!("in"), - ParseKeyword::kw_not => L!("not"), - ParseKeyword::kw_or => L!("or"), - ParseKeyword::kw_switch => L!("switch"), - ParseKeyword::kw_time => L!("time"), - ParseKeyword::kw_while => L!("while"), + ParseKeyword::And => L!("and"), + ParseKeyword::Begin => L!("begin"), + ParseKeyword::Builtin => L!("builtin"), + ParseKeyword::Case => L!("case"), + ParseKeyword::Command => L!("command"), + ParseKeyword::Else => L!("else"), + ParseKeyword::End => L!("end"), + ParseKeyword::Exclam => L!("!"), + ParseKeyword::Exec => L!("exec"), + ParseKeyword::For => L!("for"), + ParseKeyword::Function => L!("function"), + ParseKeyword::If => L!("if"), + ParseKeyword::In => L!("in"), + ParseKeyword::Not => L!("not"), + ParseKeyword::Or => L!("or"), + ParseKeyword::Switch => L!("switch"), + ParseKeyword::Time => L!("time"), + ParseKeyword::While => L!("while"), _ => L!("unknown_keyword"), } } @@ -264,25 +264,25 @@ fn to_arg(self) -> fish_printf::Arg<'static> { impl From<&wstr> for ParseKeyword { fn from(s: &wstr) -> Self { match s { - _ if s == "!" => ParseKeyword::kw_exclam, - _ if s == "and" => ParseKeyword::kw_and, - _ if s == "begin" => ParseKeyword::kw_begin, - _ if s == "builtin" => ParseKeyword::kw_builtin, - _ if s == "case" => ParseKeyword::kw_case, - _ if s == "command" => ParseKeyword::kw_command, - _ if s == "else" => ParseKeyword::kw_else, - _ if s == "end" => ParseKeyword::kw_end, - _ if s == "exec" => ParseKeyword::kw_exec, - _ if s == "for" => ParseKeyword::kw_for, - _ if s == "function" => ParseKeyword::kw_function, - _ if s == "if" => ParseKeyword::kw_if, - _ if s == "in" => ParseKeyword::kw_in, - _ if s == "not" => ParseKeyword::kw_not, - _ if s == "or" => ParseKeyword::kw_or, - _ if s == "switch" => ParseKeyword::kw_switch, - _ if s == "time" => ParseKeyword::kw_time, - _ if s == "while" => ParseKeyword::kw_while, - _ => ParseKeyword::none, + _ if s == "!" => ParseKeyword::Exclam, + _ if s == "and" => ParseKeyword::And, + _ if s == "begin" => ParseKeyword::Begin, + _ if s == "builtin" => ParseKeyword::Builtin, + _ if s == "case" => ParseKeyword::Case, + _ if s == "command" => ParseKeyword::Command, + _ if s == "else" => ParseKeyword::Else, + _ if s == "end" => ParseKeyword::End, + _ if s == "exec" => ParseKeyword::Exec, + _ if s == "for" => ParseKeyword::For, + _ if s == "function" => ParseKeyword::Function, + _ if s == "if" => ParseKeyword::If, + _ if s == "in" => ParseKeyword::In, + _ if s == "not" => ParseKeyword::Not, + _ if s == "or" => ParseKeyword::Or, + _ if s == "switch" => ParseKeyword::Switch, + _ if s == "time" => ParseKeyword::Time, + _ if s == "while" => ParseKeyword::While, + _ => ParseKeyword::None, } } } @@ -423,7 +423,7 @@ pub fn token_type_user_presentable_description( type_: ParseTokenType, keyword: ParseKeyword, ) -> WString { - if keyword != ParseKeyword::none { + if keyword != ParseKeyword::None { return sprintf!("keyword: '%ls'", keyword.to_wstr()); } match type_ { diff --git a/src/parse_execution.rs b/src/parse_execution.rs index 0a52a255c..9f6039343 100644 --- a/src/parse_execution.rs +++ b/src/parse_execution.rs @@ -1725,11 +1725,11 @@ fn test_and_run_1_job_conjunction( if let Some(deco) = &jc.decorator { let last_status = ctx.parser().get_last_status(); match deco.keyword() { - ParseKeyword::kw_and => { + ParseKeyword::And => { // AND. Skip if the last job failed. skip = last_status != 0; } - ParseKeyword::kw_or => { + ParseKeyword::Or => { // OR. Skip if the last job succeeded. skip = last_status == 0; } diff --git a/src/parse_tree.rs b/src/parse_tree.rs index bfa4d2912..4ed99e853 100644 --- a/src/parse_tree.rs +++ b/src/parse_tree.rs @@ -39,7 +39,7 @@ impl ParseToken { pub fn new(typ: ParseTokenType) -> Self { ParseToken { typ, - keyword: ParseKeyword::none, + keyword: ParseKeyword::None, has_dash_prefix: false, is_help_argument: false, is_newline: false, @@ -73,7 +73,7 @@ pub fn is_dash_prefix_string(&self) -> bool { /// Returns a string description of the given parse token. pub fn describe(&self) -> WString { let mut result = self.typ.to_wstr().to_owned(); - if self.keyword != ParseKeyword::none { + if self.keyword != ParseKeyword::None { sprintf!(=> &mut result, " <%ls>", self.keyword.to_wstr()) } result diff --git a/src/parse_util.rs b/src/parse_util.rs index f853a309f..3107fec98 100644 --- a/src/parse_util.rs +++ b/src/parse_util.rs @@ -1545,10 +1545,10 @@ fn detect_errors_in_backgrounded_job( if let Some(next) = jlist.get(index + 1) { if let Some(deco) = &next.decorator { assert!( - [ParseKeyword::kw_and, ParseKeyword::kw_or].contains(&deco.keyword()), + [ParseKeyword::And, ParseKeyword::Or].contains(&deco.keyword()), "Unexpected decorator keyword" ); - let deco_name = if deco.keyword() == ParseKeyword::kw_and { + let deco_name = if deco.keyword() == ParseKeyword::And { L!("and") } else { L!("or")