h/fish-shell
1
Fork 0
mirror of https://github.com/fish-shell/fish-shell.git synced 2026-06-09 03:51:20 -03:00
Code Issues Packages Projects Releases Wiki Activity

Switch ParseKeyword to Rust naming conventions

Browse Source
This commit is contained in:
Peter Ammon
2025-03-19 15:11:28 -07:00
parent a874237bff
commit cef7c3c5c4
6 changed files with 142 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
src/ast.rs
View File

@@ -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("<error>")
}
_ => {
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::<NotStatement>();
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::<BlockStatement>();
StatementVariant::BlockStatement(embedded)
}
ParseKeyword::kw_if => {
ParseKeyword::If => {
let embedded = self.allocate_boxed_visit::<IfStatement>();
StatementVariant::IfStatement(embedded)
}
ParseKeyword::kw_switch => {
ParseKeyword::Switch => {
let embedded = self.allocate_boxed_visit::<SwitchStatement>();
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::<ForHeader>();
BlockStatementHeaderVariant::ForHeader(embedded)
}
ParseKeyword::kw_while => {
ParseKeyword::While => {
let embedded = self.allocate_visit::<WhileHeader>();
BlockStatementHeaderVariant::WhileHeader(embedded)
}
ParseKeyword::kw_function => {
ParseKeyword::Function => {
let embedded = self.allocate_visit::<FunctionHeader>();
BlockStatementHeaderVariant::FunctionHeader(embedded)
}
ParseKeyword::kw_begin => {
ParseKeyword::Begin => {
let embedded = self.allocate_visit::<BeginHeader>();
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<kw_end>.
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)[..])
}

38
src/highlight/highlight.rs
View File

@@ -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));
}

120
src/parse_constants.rs
View File

@@ -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_ {

4
src/parse_execution.rs
View File

@@ -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;
}

4
src/parse_tree.rs
View File

@@ -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

4
src/parse_util.rs
View File

@@ -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")