#![allow(clippy::wildcard_imports, clippy::enum_glob_use)]
use super::*;
const GENERIC_ANGLES: GenericAngleKinds = GenericAngleKinds {
lists: &[
Csharp::TypeArgumentList as u16,
Csharp::TypeParameterList as u16,
Csharp::FunctionPointerType as u16,
],
openers: &[Csharp::LT as u16],
closers: &[Csharp::GT as u16],
is_misparse: csharp_comparison_misparse,
};
fn csharp_comparison_misparse<'a>(list: &Node<'a>, ancestors: Ancestors<'a, '_>) -> bool {
let mut up = ancestors.iter(list).map(|(node, _)| node);
let Some(name) = up
.next()
.filter(|name| name.kind_id() == Csharp::GenericName as u16)
else {
return false;
};
let declaration = match up.next() {
Some(qualified) if qualified.kind_id() == Csharp::QualifiedName as u16 => {
if qualified
.child_by_field_name("name")
.is_none_or(|last| last.id() != name.id())
{
return false;
}
up.next()
}
parent => parent,
};
let (Some(declaration), Some(argument), Some(arguments)) = (declaration, up.next(), up.next())
else {
return false;
};
declaration.kind_id() == Csharp::DeclarationExpression as u16
&& argument.kind_id() == Csharp::Argument as u16
&& !argument.is_child(Csharp::Out as u16)
&& matches!(
arguments.kind_id().into(),
Csharp::ArgumentList | Csharp::BracketedArgumentList
)
}
fn is_interpolation_clause_delimiter<'a>(node: &Node<'a>, ancestors: Ancestors<'a, '_>) -> bool {
let clause = match node.kind_id().into() {
Csharp::COLON => Csharp::InterpolationFormatClause,
Csharp::COMMA => Csharp::InterpolationAlignmentClause,
_ => return false,
};
ancestors.parent_has_kind(node, clause as u16)
}
impl Getter for CsharpCode {
fn get_space_kind(node: &Node) -> SpaceKind {
const _: () = assert!(
!crate::roles::csharp::func_opener::TEXT_GATED
&& !crate::roles::csharp::container::TEXT_GATED
&& !crate::roles::csharp::container::CHAIN_GATED,
"a space-opening row reads bytes; the byte-less spelling cannot forward with none"
);
Self::get_space_kind_with_code(node, &[], Ancestors::known(&[]))
}
fn get_func_space_name<'a, 'tree>(
node: &Node<'tree>,
code: &'a [u8],
ancestors: Ancestors<'tree, '_>,
) -> Option<&'a str> {
crate::getter::func_space_name_from_owner(node, code, ancestors, |list, owner| {
list.kind_id() == Csharp::ParameterList as u16
&& crate::roles::csharp::container::lists_kind(owner.kind_id())
})
}
fn get_space_kind_with_code<'a>(
node: &Node<'a>,
code: &[u8],
ancestors: Ancestors<'a, '_>,
) -> SpaceKind {
crate::roles::csharp::opens_space(node, code, ancestors)
}
keyword_roles!(csharp);
paying_roles!(csharp);
fn get_op_type<'a>(node: &Node<'a>, ancestors: Ancestors<'a, '_>) -> TokenRole {
use Csharp::*;
if GENERIC_ANGLES.is_closer(node, ancestors)
|| is_interpolation_clause_delimiter(node, ancestors)
{
return TokenRole::Unknown;
}
match node.kind_id().into() {
If | Else | Switch | Case | Default | Try | Catch | Finally | Throw
| Return | Yield | Break | Continue | Goto | For | Foreach | While | Do
| Is
| New | Await | As | Typeof | Sizeof | Checked | Unchecked | Ref | Out | In
| Params | Lock | Stackalloc | Where | With | When | Operator
| Scoped | Not | And | Or
| Get | Set | Init | Add | Remove
| LBRACE | LBRACK | LPAREN | COMMA | SEMI | COLON | COLONCOLON | DOT
| DOTDOT | EQGT | DASHGT | QMARK
| EQ | EQEQ | BANGEQ | LT | GT | LTEQ | GTEQ
| PLUS | DASH | STAR | SLASH | PERCENT
| AMP | PIPE | CARET | TILDE | BANG
| LTLT | GTGT | GTGTGT
| PLUSPLUS | DASHDASH
| PLUSEQ | DASHEQ | STAREQ | SLASHEQ | PERCENTEQ
| AMPEQ | PIPEEQ | CARETEQ | LTLTEQ | GTGTEQ | GTGTGTEQ | QMARKQMARKEQ
=> TokenRole::Operator,
True | False => match ancestors.parent(node).map(|p| p.kind_id().into()) {
Some(BooleanLiteral) => TokenRole::Unknown,
Some(OperatorDeclaration) => TokenRole::Operator,
_ => TokenRole::Operand,
},
This => match ancestors.parent(node).map(|p| p.kind_id().into()) {
Some(IndexerDeclaration) => TokenRole::Operator,
_ => TokenRole::Operand,
},
Identifier | Base | ImplicitParameter
| IntegerLiteral | RealLiteral | BooleanLiteral | NullLiteral
| CharacterLiteral | StringLiteral | VerbatimStringLiteral | RawStringLiteral
=> TokenRole::Operand,
InterpolatedStringExpression => {
Self::string_operand_type(node, crate::roles::csharp::string_lit::WRAPS)
}
_ => TokenRole::Unknown,
}
}
fn get_op_type_with_code<'a>(
node: &Node<'a>,
code: &[u8],
ancestors: Ancestors<'a, '_>,
) -> TokenRole {
if csharp_is_aliased_modifier(node) && node_text(code, node) == Some("this") {
return TokenRole::Operand;
}
keyword_or_op_type::<Self>(node, code, ancestors)
}
fn get_operator_spelling<'a>(
node: &Node<'a>,
ancestors: Ancestors<'a, '_>,
) -> Option<&'static str> {
GENERIC_ANGLES.opener_spelling(node, ancestors)
}
get_operator!(Csharp);
}