#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum DiagnosticCode {
SyntaxError,
ParamTypeCheck,
AssignTypeCheck,
UndefinedField,
UndefinedName,
Redefinition,
Unused,
UnnecessaryBranch,
ArgumentCount,
ReturnTypeMismatch,
MacroRedefined,
ConceptNotSatisfied,
IncludeNotFound,
AccessInvisible,
MissingReturn,
AssignmentInCondition,
ModuleNote,
BracesAroundStatements,
UseNullptr,
UseOverride,
SimplifyBooleanExpr,
ElseAfterReturn,
CStyleCast,
UseAuto,
MacroParentheses,
ImplicitBoolConversion,
}
impl DiagnosticCode {
pub const ALL: [DiagnosticCode; 26] = [
DiagnosticCode::SyntaxError,
DiagnosticCode::ParamTypeCheck,
DiagnosticCode::AssignTypeCheck,
DiagnosticCode::UndefinedField,
DiagnosticCode::UndefinedName,
DiagnosticCode::Redefinition,
DiagnosticCode::Unused,
DiagnosticCode::UnnecessaryBranch,
DiagnosticCode::ArgumentCount,
DiagnosticCode::ReturnTypeMismatch,
DiagnosticCode::MacroRedefined,
DiagnosticCode::IncludeNotFound,
DiagnosticCode::AccessInvisible,
DiagnosticCode::MissingReturn,
DiagnosticCode::AssignmentInCondition,
DiagnosticCode::ModuleNote,
DiagnosticCode::BracesAroundStatements,
DiagnosticCode::UseNullptr,
DiagnosticCode::UseOverride,
DiagnosticCode::SimplifyBooleanExpr,
DiagnosticCode::ElseAfterReturn,
DiagnosticCode::CStyleCast,
DiagnosticCode::UseAuto,
DiagnosticCode::MacroParentheses,
DiagnosticCode::ImplicitBoolConversion,
DiagnosticCode::ConceptNotSatisfied,
];
pub fn name(self) -> &'static str {
match self {
DiagnosticCode::SyntaxError => "syntax-error",
DiagnosticCode::ParamTypeCheck => "param-type-check",
DiagnosticCode::AssignTypeCheck => "assign-type-check",
DiagnosticCode::UndefinedField => "undefined-field",
DiagnosticCode::UndefinedName => "undefined-name",
DiagnosticCode::Redefinition => "redefinition",
DiagnosticCode::Unused => "unused",
DiagnosticCode::UnnecessaryBranch => "unnecessary-branch",
DiagnosticCode::ArgumentCount => "argument-count",
DiagnosticCode::ReturnTypeMismatch => "return-type-mismatch",
DiagnosticCode::MacroRedefined => "macro-redefined",
DiagnosticCode::IncludeNotFound => "include-not-found",
DiagnosticCode::AccessInvisible => "access-invisible",
DiagnosticCode::MissingReturn => "missing-return",
DiagnosticCode::AssignmentInCondition => "assignment-in-condition",
DiagnosticCode::ModuleNote => "module-note",
DiagnosticCode::BracesAroundStatements => "braces-around-statements",
DiagnosticCode::UseNullptr => "use-nullptr",
DiagnosticCode::UseOverride => "use-override",
DiagnosticCode::SimplifyBooleanExpr => "simplify-boolean-expr",
DiagnosticCode::ElseAfterReturn => "else-after-return",
DiagnosticCode::CStyleCast => "cstyle-cast",
DiagnosticCode::UseAuto => "use-auto",
DiagnosticCode::MacroParentheses => "macro-parentheses",
DiagnosticCode::ImplicitBoolConversion => "implicit-bool-conversion",
DiagnosticCode::ConceptNotSatisfied => "concept-not-satisfied",
}
}
pub fn from_name(name: &str) -> Option<DiagnosticCode> {
DiagnosticCode::ALL
.into_iter()
.find(|code| code.name() == name)
}
pub fn severity(self) -> RuleSeverity {
match self {
DiagnosticCode::SyntaxError => RuleSeverity::Error,
DiagnosticCode::IncludeNotFound => RuleSeverity::Error,
DiagnosticCode::ParamTypeCheck => RuleSeverity::Error,
DiagnosticCode::AssignTypeCheck => RuleSeverity::Error,
DiagnosticCode::UndefinedField => RuleSeverity::Error,
DiagnosticCode::UndefinedName => RuleSeverity::Error,
DiagnosticCode::Redefinition => RuleSeverity::Error,
DiagnosticCode::ArgumentCount => RuleSeverity::Error,
DiagnosticCode::ReturnTypeMismatch => RuleSeverity::Error,
DiagnosticCode::ConceptNotSatisfied => RuleSeverity::Error,
DiagnosticCode::MacroRedefined => RuleSeverity::Warning,
DiagnosticCode::UnnecessaryBranch => RuleSeverity::Warning,
DiagnosticCode::Unused => RuleSeverity::Hint,
DiagnosticCode::AccessInvisible => RuleSeverity::Error,
DiagnosticCode::MissingReturn => RuleSeverity::Error,
DiagnosticCode::AssignmentInCondition => RuleSeverity::Warning,
DiagnosticCode::ModuleNote => RuleSeverity::Information,
DiagnosticCode::BracesAroundStatements => RuleSeverity::Hint,
DiagnosticCode::UseNullptr => RuleSeverity::Hint,
DiagnosticCode::UseOverride => RuleSeverity::Hint,
DiagnosticCode::SimplifyBooleanExpr => RuleSeverity::Hint,
DiagnosticCode::ElseAfterReturn => RuleSeverity::Hint,
DiagnosticCode::CStyleCast => RuleSeverity::Warning,
DiagnosticCode::UseAuto => RuleSeverity::Hint,
DiagnosticCode::MacroParentheses => RuleSeverity::Warning,
DiagnosticCode::ImplicitBoolConversion => RuleSeverity::Hint,
}
}
pub fn tags(self) -> &'static [RuleTag] {
match self {
DiagnosticCode::Unused => &[RuleTag::Unnecessary],
DiagnosticCode::UnnecessaryBranch => &[RuleTag::Unnecessary],
_ => &[],
}
}
pub fn is_a_complaint(self) -> bool {
!matches!(self, DiagnosticCode::ModuleNote)
}
pub fn is_cpp_only(self) -> bool {
matches!(
self,
DiagnosticCode::UseNullptr
| DiagnosticCode::UseAuto
| DiagnosticCode::UseOverride
| DiagnosticCode::CStyleCast
| DiagnosticCode::AccessInvisible
| DiagnosticCode::ConceptNotSatisfied
| DiagnosticCode::ModuleNote
| DiagnosticCode::ImplicitBoolConversion
)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum RuleTag {
Unnecessary,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum RuleSeverity {
Error,
Warning,
Hint,
Information,
}