| use std::fmt; |
| |
| use crate::{ |
| bans::{cfg, SpecAndReason}, |
| diag::{ |
| CfgCoord, Check, Diag, Diagnostic, FileId, GraphNode, KrateCoord, Label, Pack, Severity, |
| }, |
| Krate, Spanned, |
| }; |
| |
| #[derive( |
| strum::Display, |
| strum::EnumString, |
| strum::EnumIter, |
| strum::IntoStaticStr, |
| Copy, |
| Clone, |
| Debug, |
| PartialEq, |
| Eq, |
| )] |
| #[strum(serialize_all = "kebab-case")] |
| pub enum Code { |
| Banned, |
| Allowed, |
| NotAllowed, |
| Duplicate, |
| Skipped, |
| Wildcard, |
| UnmatchedSkip, |
| AllowedByWrapper, |
| UnmatchedWrapper, |
| SkippedByRoot, |
| UnmatchedSkipRoot, |
| BuildScriptNotAllowed, |
| ExactFeaturesMismatch, |
| FeatureNotExplicitlyAllowed, |
| FeatureBanned, |
| UnknownFeature, |
| DefaultFeatureEnabled, |
| PathBypassed, |
| PathBypassedByGlob, |
| ChecksumMatch, |
| ChecksumMismatch, |
| DeniedByExtension, |
| DetectedExecutable, |
| DetectedExecutableScript, |
| UnableToCheckPath, |
| FeaturesEnabled, |
| UnmatchedBypass, |
| UnmatchedPathBypass, |
| UnmatchedGlob, |
| UnusedWrapper, |
| } |
| |
| impl From<Code> for String { |
| fn from(c: Code) -> Self { |
| c.to_string() |
| } |
| } |
| |
| impl SpecAndReason { |
| pub(crate) fn to_labels(&self, spec_msg: Option<&str>) -> Vec<Label> { |
| let mut v = Vec::new(); |
| |
| { |
| let l = Label::primary(self.file_id, self.spec.name.span); |
| if let Some(sm) = spec_msg { |
| v.push(l.with_message(sm)); |
| } else { |
| v.push(l); |
| } |
| } |
| |
| if let Some(reason) = &self.reason { |
| v.push(Label::secondary(self.file_id, reason.0.span).with_message("reason")); |
| } |
| |
| if let Some(ui) = &self.use_instead { |
| v.push(Label::secondary(self.file_id, ui.span).with_message("use instead")); |
| } |
| |
| v |
| } |
| } |
| |
| pub(crate) struct ExplicitlyBanned<'a> { |
| pub(crate) krate: &'a Krate, |
| pub(crate) ban_cfg: &'a SpecAndReason, |
| } |
| |
| impl<'a> From<ExplicitlyBanned<'a>> for Diag { |
| fn from(eb: ExplicitlyBanned<'a>) -> Self { |
| Diagnostic::new(Severity::Error) |
| .with_message(format!("crate '{}' is explicitly banned", eb.krate)) |
| .with_code(Code::Banned) |
| .with_labels(eb.ban_cfg.to_labels(Some("banned here"))) |
| .into() |
| } |
| } |
| |
| pub(crate) struct ExplicitlyAllowed<'a> { |
| pub(crate) krate: &'a Krate, |
| pub(crate) allow_cfg: &'a SpecAndReason, |
| } |
| |
| impl<'a> From<ExplicitlyAllowed<'a>> for Diag { |
| fn from(ea: ExplicitlyAllowed<'a>) -> Self { |
| Diagnostic::new(Severity::Note) |
| .with_message(format!("crate '{}' is explicitly allowed", ea.krate)) |
| .with_code(Code::Allowed) |
| .with_labels(ea.allow_cfg.to_labels(Some("allowed here"))) |
| .into() |
| } |
| } |
| |
| pub(crate) struct NotAllowed<'a> { |
| pub(crate) krate: &'a Krate, |
| } |
| |
| impl<'a> From<NotAllowed<'a>> for Diag { |
| fn from(ib: NotAllowed<'a>) -> Self { |
| Diagnostic::new(Severity::Error) |
| .with_message(format!("crate '{}' is not explicitly allowed", ib.krate)) |
| .with_code(Code::NotAllowed) |
| .into() |
| } |
| } |
| |
| pub(crate) struct Duplicates<'a> { |
| pub(crate) krate_name: &'a str, |
| pub(crate) num_dupes: usize, |
| pub(crate) krates_coord: KrateCoord, |
| pub(crate) severity: Severity, |
| } |
| |
| impl<'a> From<Duplicates<'a>> for Diag { |
| fn from(dup: Duplicates<'a>) -> Self { |
| Diagnostic::new(dup.severity) |
| .with_message(format!( |
| "found {} duplicate entries for crate '{}'", |
| dup.num_dupes, dup.krate_name, |
| )) |
| .with_code(Code::Duplicate) |
| .with_labels(vec![dup |
| .krates_coord |
| .into_label() |
| .with_message("lock entries")]) |
| .into() |
| } |
| } |
| |
| pub(crate) struct Skipped<'a> { |
| pub(crate) krate: &'a Krate, |
| pub(crate) skip_cfg: &'a SpecAndReason, |
| } |
| |
| impl<'a> From<Skipped<'a>> for Diag { |
| fn from(sk: Skipped<'a>) -> Self { |
| Diagnostic::new(Severity::Note) |
| .with_message(format!( |
| "crate '{}' skipped when checking for duplicates", |
| sk.krate |
| )) |
| .with_code(Code::Skipped) |
| .with_labels(sk.skip_cfg.to_labels(Some("skipped here"))) |
| .into() |
| } |
| } |
| |
| pub(crate) struct Wildcards<'a> { |
| pub(crate) krate: &'a Krate, |
| pub(crate) severity: Severity, |
| pub(crate) wildcards: Vec<&'a krates::cm::Dependency>, |
| pub(crate) allow_wildcard_paths: bool, |
| pub(crate) cargo_spans: &'a crate::diag::CargoSpans, |
| } |
| |
| impl<'a> From<Wildcards<'a>> for Pack { |
| fn from(wc: Wildcards<'a>) -> Self { |
| let (file_id, map) = &wc.cargo_spans[&wc.krate.id]; |
| |
| let labels: Vec<_> = wc |
| .wildcards |
| .into_iter() |
| .map(|dep| { |
| Label::primary(*file_id, map[&dep.name].clone()) |
| .with_message("wildcard crate entry") |
| }) |
| .collect(); |
| |
| let diag = Diag::new( |
| Diagnostic::new(wc.severity) |
| .with_message(format!( |
| "found {} wildcard dependenc{} for crate '{}'{}", |
| labels.len(), |
| if labels.len() == 1 { "y" } else { "ies" }, |
| wc.krate.name, |
| if wc.allow_wildcard_paths { |
| ". allow-wildcard-paths is enabled, but does not apply to public crates as crates.io disallows path dependencies." |
| } else { |
| "" |
| }, |
| )) |
| .with_code(Code::Wildcard) |
| .with_labels(labels), |
| ); |
| |
| let mut pack = Pack::with_kid(Check::Bans, wc.krate.id.clone()); |
| pack.push(diag); |
| |
| pack |
| } |
| } |
| |
| pub(crate) struct UnmatchedSkip<'a> { |
| pub(crate) skip_cfg: &'a SpecAndReason, |
| } |
| |
| impl<'a> From<UnmatchedSkip<'a>> for Diag { |
| fn from(us: UnmatchedSkip<'a>) -> Self { |
| Diagnostic::new(Severity::Warning) |
| .with_message(format!( |
| "skipped crate '{}' was not encountered", |
| us.skip_cfg.spec, |
| )) |
| .with_code(Code::UnmatchedSkip) |
| .with_labels(us.skip_cfg.to_labels(Some("unmatched skip configuration"))) |
| .into() |
| } |
| } |
| |
| pub(crate) struct UnusedWrapper { |
| pub(crate) wrapper_cfg: CfgCoord, |
| } |
| |
| impl From<UnusedWrapper> for Diag { |
| fn from(us: UnusedWrapper) -> Self { |
| Diagnostic::new(Severity::Warning) |
| .with_message("wrapper for banned crate was not encountered") |
| .with_code(Code::UnusedWrapper) |
| .with_labels(vec![us |
| .wrapper_cfg |
| .into_label() |
| .with_message("unmatched wrapper")]) |
| .into() |
| } |
| } |
| |
| pub(crate) struct BannedAllowedByWrapper<'a> { |
| pub(crate) ban_cfg: CfgCoord, |
| pub(crate) banned_krate: &'a Krate, |
| pub(crate) ban_exception_cfg: CfgCoord, |
| pub(crate) wrapper_krate: &'a Krate, |
| } |
| |
| impl<'a> From<BannedAllowedByWrapper<'a>> for Diag { |
| fn from(baw: BannedAllowedByWrapper<'a>) -> Self { |
| Diagnostic::new(Severity::Note) |
| .with_message(format!( |
| "banned crate '{}' allowed by wrapper '{}'", |
| baw.banned_krate, baw.wrapper_krate |
| )) |
| .with_code(Code::AllowedByWrapper) |
| .with_labels(vec![ |
| baw.ban_cfg.into_label().with_message("banned here"), |
| baw.ban_exception_cfg |
| .into_label() |
| .with_message("allowed wrapper"), |
| ]) |
| .into() |
| } |
| } |
| |
| pub(crate) struct BannedUnmatchedWrapper<'a> { |
| pub(crate) ban_cfg: &'a SpecAndReason, |
| pub(crate) banned_krate: &'a Krate, |
| pub(crate) parent_krate: &'a Krate, |
| } |
| |
| impl<'a> From<BannedUnmatchedWrapper<'a>> for Diag { |
| fn from(buw: BannedUnmatchedWrapper<'a>) -> Self { |
| Diagnostic::new(Severity::Warning) |
| .with_message(format!( |
| "direct parent '{}' of banned crate '{}' was not marked as a wrapper", |
| buw.parent_krate, buw.banned_krate |
| )) |
| .with_code(Code::UnmatchedWrapper) |
| .with_labels(buw.ban_cfg.to_labels(Some("banned here"))) |
| .into() |
| } |
| } |
| |
| pub(crate) struct SkippedByRoot<'a> { |
| pub(crate) krate: &'a Krate, |
| pub(crate) skip_root_cfg: &'a SpecAndReason, |
| } |
| |
| impl<'a> From<SkippedByRoot<'a>> for Diag { |
| fn from(sbr: SkippedByRoot<'a>) -> Self { |
| Diagnostic::new(Severity::Note) |
| .with_message(format!("skipping crate '{}' due to root skip", sbr.krate)) |
| .with_code(Code::SkippedByRoot) |
| .with_labels(sbr.skip_root_cfg.to_labels(Some("matched skip root"))) |
| .into() |
| } |
| } |
| |
| pub(crate) struct UnmatchedSkipRoot { |
| pub(crate) skip_root_cfg: CfgCoord, |
| } |
| |
| impl From<UnmatchedSkipRoot> for Diag { |
| fn from(usr: UnmatchedSkipRoot) -> Self { |
| Diagnostic::new(Severity::Warning) |
| .with_message("skip tree root was not found in the dependency graph") |
| .with_code(Code::UnmatchedSkipRoot) |
| .with_labels(vec![usr |
| .skip_root_cfg |
| .into_label() |
| .with_message("no crate matched these criteria")]) |
| .into() |
| } |
| } |
| |
| pub(crate) struct BuildScriptNotAllowed<'a> { |
| pub(crate) krate: &'a Krate, |
| } |
| |
| impl<'a> From<BuildScriptNotAllowed<'a>> for Diag { |
| fn from(bs: BuildScriptNotAllowed<'a>) -> Self { |
| Diagnostic::new(Severity::Error) |
| .with_message(format!( |
| "crate '{}' has a build script but is not allowed to have one", |
| bs.krate |
| )) |
| .with_code(Code::BuildScriptNotAllowed) |
| .into() |
| } |
| } |
| |
| pub(crate) struct ExactFeaturesMismatch<'a> { |
| pub(crate) missing_allowed: Vec<CfgCoord>, |
| pub(crate) not_allowed: &'a [&'a str], |
| pub(crate) exact_coord: CfgCoord, |
| pub(crate) krate: &'a Krate, |
| } |
| |
| impl From<ExactFeaturesMismatch<'_>> for Diag { |
| fn from(efm: ExactFeaturesMismatch<'_>) -> Self { |
| let mut labels = vec![efm |
| .exact_coord |
| .into_label() |
| .with_message("exact enabled here")]; |
| |
| labels.extend( |
| efm.missing_allowed |
| .into_iter() |
| .map(|ma| ma.into_label().with_message("allowed feature not present")), |
| ); |
| |
| let diag = Diagnostic::new(Severity::Error) |
| .with_message(format!( |
| "feature set for crate '{}' did not match exactly", |
| efm.krate |
| )) |
| .with_code(Code::ExactFeaturesMismatch) |
| .with_labels(labels) |
| .with_notes( |
| efm.not_allowed |
| .iter() |
| .map(|na| format!("'{na}' feature was enabled but not explicitly allowed")) |
| .collect(), |
| ); |
| |
| let graph_nodes = if efm.not_allowed.is_empty() { |
| vec![GraphNode { |
| kid: efm.krate.id.clone(), |
| feature: None, |
| }] |
| } else { |
| efm.not_allowed |
| .iter() |
| .map(|feat| GraphNode { |
| kid: efm.krate.id.clone(), |
| feature: Some((*feat).to_owned()), |
| }) |
| .collect() |
| }; |
| |
| Diag { |
| diag, |
| graph_nodes: graph_nodes.into(), |
| extra: None, |
| with_features: true, |
| } |
| } |
| } |
| |
| pub(crate) struct FeatureNotExplicitlyAllowed<'a> { |
| pub(crate) krate: &'a Krate, |
| pub(crate) feature: &'a str, |
| pub(crate) allowed: CfgCoord, |
| } |
| |
| impl From<FeatureNotExplicitlyAllowed<'_>> for Diag { |
| fn from(fna: FeatureNotExplicitlyAllowed<'_>) -> Diag { |
| let diag = Diagnostic::new(Severity::Error) |
| .with_message(format!( |
| "feature '{}' for crate '{}' was not explicitly allowed", |
| fna.feature, fna.krate, |
| )) |
| .with_code(Code::FeatureNotExplicitlyAllowed) |
| .with_labels(vec![fna |
| .allowed |
| .into_label() |
| .with_message("allowed features")]); |
| |
| Diag { |
| diag, |
| graph_nodes: std::iter::once(GraphNode { |
| kid: fna.krate.id.clone(), |
| feature: None, |
| }) |
| .collect(), |
| extra: None, |
| with_features: true, |
| } |
| } |
| } |
| |
| pub(crate) struct FeatureBanned<'a> { |
| pub(crate) krate: &'a Krate, |
| pub(crate) feature: &'a Spanned<String>, |
| pub(crate) file_id: FileId, |
| } |
| |
| impl From<FeatureBanned<'_>> for Diag { |
| fn from(fed: FeatureBanned<'_>) -> Diag { |
| let diag = Diagnostic::new(Severity::Error) |
| .with_message(format!( |
| "feature '{}' for crate '{}' is explicitly denied", |
| fed.feature.value, fed.krate, |
| )) |
| .with_code(Code::FeatureBanned) |
| .with_labels(vec![ |
| Label::primary(fed.file_id, fed.feature.span).with_message("feature denied here") |
| ]); |
| |
| Diag { |
| diag, |
| graph_nodes: std::iter::once(GraphNode { |
| kid: fed.krate.id.clone(), |
| feature: Some(fed.feature.value.clone()), |
| }) |
| .collect(), |
| extra: None, |
| with_features: true, |
| } |
| } |
| } |
| |
| pub(crate) struct UnknownFeature<'a> { |
| pub(crate) krate: &'a Krate, |
| pub(crate) feature: &'a Spanned<String>, |
| pub(crate) file_id: FileId, |
| } |
| |
| impl From<UnknownFeature<'_>> for Diag { |
| fn from(uf: UnknownFeature<'_>) -> Diag { |
| let diag = Diagnostic::new(Severity::Warning) |
| .with_message(format!( |
| "found unknown feature '{}' for crate '{}'", |
| uf.feature.value, uf.krate, |
| )) |
| .with_code(Code::UnknownFeature) |
| .with_labels(vec![ |
| Label::primary(uf.file_id, uf.feature.span).with_message("unknown feature") |
| ]); |
| |
| Diag { |
| diag, |
| graph_nodes: std::iter::once(GraphNode { |
| kid: uf.krate.id.clone(), |
| feature: None, |
| }) |
| .collect(), |
| extra: None, |
| with_features: false, |
| } |
| } |
| } |
| |
| pub(crate) struct DefaultFeatureEnabled<'a> { |
| pub(crate) krate: &'a Krate, |
| pub(crate) level: &'a Spanned<crate::LintLevel>, |
| pub(crate) file_id: FileId, |
| } |
| |
| impl From<DefaultFeatureEnabled<'_>> for Diag { |
| fn from(dfe: DefaultFeatureEnabled<'_>) -> Diag { |
| let diag = Diagnostic::new(dfe.level.value.into()) |
| .with_message(format!( |
| "'default' feature enabled for crate '{}'", |
| dfe.krate, |
| )) |
| .with_code(Code::DefaultFeatureEnabled) |
| .with_labels(vec![ |
| Label::primary(dfe.file_id, dfe.level.span).with_message("lint level") |
| ]); |
| |
| Diag { |
| diag, |
| graph_nodes: std::iter::once(GraphNode { |
| kid: dfe.krate.id.clone(), |
| feature: Some("default".to_owned()), |
| }) |
| .collect(), |
| extra: None, |
| with_features: true, |
| } |
| } |
| } |
| |
| pub(crate) struct HomePath<'a> { |
| pub(crate) path: &'a crate::Path, |
| pub(crate) root: &'a crate::Path, |
| pub(crate) home: Option<&'a crate::Path>, |
| } |
| |
| impl<'a> fmt::Display for HomePath<'a> { |
| fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { |
| if let Some(rel_path) = self.home.and_then(|home| self.path.strip_prefix(home).ok()) { |
| f.write_str("$CARGO_HOME/")?; |
| f.write_str(rel_path.as_str()) |
| } else if let Ok(rel_path) = self.path.strip_prefix(self.root) { |
| f.write_str("$crate/")?; |
| f.write_str(rel_path.as_str()) |
| } else { |
| f.write_str(self.path.as_str()) |
| } |
| } |
| } |
| |
| pub(crate) struct ExplicitPathAllowance<'a> { |
| pub(crate) allowed: &'a cfg::BypassPath, |
| pub(crate) file_id: FileId, |
| } |
| |
| impl From<ExplicitPathAllowance<'_>> for Diag { |
| fn from(pa: ExplicitPathAllowance<'_>) -> Diag { |
| let mut labels = |
| vec![Label::primary(pa.file_id, pa.allowed.path.span).with_message("allowed path")]; |
| |
| labels.extend( |
| pa.allowed |
| .checksum |
| .as_ref() |
| .map(|chk| Label::secondary(pa.file_id, chk.span).with_message("matched checksum")), |
| ); |
| let diag = Diagnostic::new(Severity::Help) |
| .with_message("file explicitly allowed") |
| .with_code(Code::PathBypassed) |
| .with_labels(labels); |
| |
| Diag { |
| diag, |
| // Not really helpful to show graphs for these |
| graph_nodes: Default::default(), |
| extra: None, |
| with_features: false, |
| } |
| } |
| } |
| |
| #[inline] |
| fn globs_to_labels(file_id: FileId, globs: Vec<&cfg::GlobPattern>) -> Vec<Label> { |
| globs |
| .into_iter() |
| .map(|gp| match gp { |
| cfg::GlobPattern::Builtin((glob, id)) => { |
| Label::secondary(*id, glob.span).with_message("builtin") |
| } |
| cfg::GlobPattern::User(glob) => Label::secondary(file_id, glob.span), |
| }) |
| .collect() |
| } |
| |
| pub(crate) struct GlobAllowance<'a> { |
| pub(crate) path: HomePath<'a>, |
| pub(crate) globs: Vec<&'a cfg::GlobPattern>, |
| pub(crate) file_id: FileId, |
| } |
| |
| impl From<GlobAllowance<'_>> for Diag { |
| fn from(pa: GlobAllowance<'_>) -> Diag { |
| let diag = Diagnostic::new(Severity::Help) |
| .with_message("file allowed by glob") |
| .with_notes(vec![format!("path = '{}'", pa.path)]) |
| .with_code(Code::PathBypassedByGlob) |
| .with_labels(globs_to_labels(pa.file_id, pa.globs)); |
| |
| Diag { |
| diag, |
| // Not really helpful to show graphs for these |
| graph_nodes: Default::default(), |
| extra: None, |
| with_features: false, |
| } |
| } |
| } |
| |
| pub(crate) struct ChecksumMatch<'a> { |
| pub(crate) path: HomePath<'a>, |
| pub(crate) checksum: &'a Spanned<super::cfg::Checksum>, |
| pub(crate) severity: Option<Severity>, |
| pub(crate) file_id: FileId, |
| } |
| |
| impl From<ChecksumMatch<'_>> for Diag { |
| fn from(cm: ChecksumMatch<'_>) -> Diag { |
| let diag = Diagnostic::new(cm.severity.unwrap_or(Severity::Help)) |
| .with_message("file checksum matched") |
| .with_notes(vec![format!("path = '{}'", cm.path)]) |
| .with_code(Code::ChecksumMatch) |
| .with_labels(vec![ |
| Label::primary(cm.file_id, cm.checksum.span).with_message("checksum") |
| ]); |
| |
| Diag { |
| diag, |
| // Not really helpful to show graphs for these |
| graph_nodes: Default::default(), |
| extra: None, |
| with_features: false, |
| } |
| } |
| } |
| |
| pub(crate) struct ChecksumMismatch<'a> { |
| pub(crate) path: HomePath<'a>, |
| pub(crate) checksum: &'a Spanned<super::cfg::Checksum>, |
| pub(crate) severity: Option<Severity>, |
| pub(crate) error: String, |
| pub(crate) file_id: FileId, |
| } |
| |
| impl From<ChecksumMismatch<'_>> for Diag { |
| fn from(cm: ChecksumMismatch<'_>) -> Diag { |
| let mut notes = vec![format!("path = '{}'", cm.path)]; |
| notes.extend( |
| format!("error = {:#}", cm.error) |
| .lines() |
| .map(|l| l.to_owned()), |
| ); |
| |
| let diag = Diagnostic::new(cm.severity.unwrap_or(Severity::Error)) |
| .with_message("file did not match the expected checksum") |
| .with_notes(notes) |
| .with_code(Code::ChecksumMismatch) |
| .with_labels(vec![ |
| Label::primary(cm.file_id, cm.checksum.span).with_message("expected checksum") |
| ]); |
| |
| Diag { |
| diag, |
| // Not really helpful to show graphs for these |
| graph_nodes: Default::default(), |
| extra: None, |
| with_features: false, |
| } |
| } |
| } |
| |
| pub(crate) struct DeniedByExtension<'a> { |
| pub(crate) path: HomePath<'a>, |
| pub(crate) globs: Vec<&'a cfg::GlobPattern>, |
| pub(crate) file_id: FileId, |
| } |
| |
| impl From<DeniedByExtension<'_>> for Diag { |
| fn from(de: DeniedByExtension<'_>) -> Diag { |
| let diag = Diagnostic::new(Severity::Error) |
| .with_message("path disallowed by extension") |
| .with_notes(vec![format!("path = '{}'", de.path)]) |
| .with_code(Code::DeniedByExtension) |
| .with_labels(globs_to_labels(de.file_id, de.globs)); |
| |
| Diag { |
| diag, |
| // Not really helpful to show graphs for these |
| graph_nodes: Default::default(), |
| extra: None, |
| with_features: false, |
| } |
| } |
| } |
| |
| pub(crate) struct DetectedExecutable<'a> { |
| pub(crate) path: HomePath<'a>, |
| pub(crate) interpreted: crate::LintLevel, |
| pub(crate) exe_kind: super::ExecutableKind, |
| } |
| |
| impl From<DetectedExecutable<'_>> for Diag { |
| fn from(de: DetectedExecutable<'_>) -> Diag { |
| let (code, exe_note, severity) = match de.exe_kind { |
| super::ExecutableKind::Native(hint) => { |
| let native_kind = match hint { |
| goblin::Hint::Elf(_) => "elf", |
| goblin::Hint::PE => "pe", |
| goblin::Hint::Mach(_) | goblin::Hint::MachFat(_) => "mach", |
| goblin::Hint::Archive => "archive", |
| _ => unreachable!("unhandled format {hint:#?} for {}", de.path), |
| }; |
| |
| ( |
| Code::DetectedExecutable, |
| format!("executable-kind = '{native_kind}'"), |
| Severity::Error, |
| ) |
| } |
| super::ExecutableKind::Interpreted(interpreter) => ( |
| Code::DetectedExecutableScript, |
| format!("interpreter = '{interpreter}'"), |
| de.interpreted.into(), |
| ), |
| }; |
| |
| let diag = Diagnostic::new(severity) |
| .with_message("detected executable") |
| .with_notes(vec![format!("path = '{}'", de.path), exe_note]) |
| .with_code(code); |
| |
| Diag { |
| diag, |
| // Not really helpful to show graphs for these |
| graph_nodes: Default::default(), |
| extra: None, |
| with_features: false, |
| } |
| } |
| } |
| |
| pub(crate) struct UnableToCheckPath<'a> { |
| pub(crate) path: HomePath<'a>, |
| pub(crate) error: anyhow::Error, |
| } |
| |
| impl From<UnableToCheckPath<'_>> for Diag { |
| fn from(ucp: UnableToCheckPath<'_>) -> Diag { |
| let mut notes = vec![format!("path = {}", ucp.path)]; |
| |
| notes.extend( |
| format!("error = {:#}", ucp.error) |
| .lines() |
| .map(|l| l.to_owned()), |
| ); |
| let diag = Diagnostic::new(Severity::Error) |
| .with_message("unable to check if path is an executable") |
| .with_notes(notes) |
| .with_code(Code::UnableToCheckPath); |
| |
| Diag { |
| diag, |
| // Not really helpful to show graphs for these |
| graph_nodes: Default::default(), |
| extra: None, |
| with_features: false, |
| } |
| } |
| } |
| |
| pub(crate) struct FeaturesEnabled<'a> { |
| pub(crate) enabled_features: Vec<&'a Spanned<String>>, |
| pub(crate) file_id: FileId, |
| } |
| |
| impl From<FeaturesEnabled<'_>> for Diag { |
| fn from(fe: FeaturesEnabled<'_>) -> Diag { |
| let diag = Diagnostic::new(Severity::Note) |
| .with_message(format!( |
| "{} features enabled for crate with build script, checking sources", |
| fe.enabled_features.len() |
| )) |
| .with_code(Code::FeaturesEnabled) |
| .with_labels( |
| fe.enabled_features |
| .into_iter() |
| .map(|ef| Label::secondary(fe.file_id, ef.span)) |
| .collect(), |
| ); |
| |
| Diag { |
| diag, |
| // Not really helpful to show graphs for these |
| graph_nodes: Default::default(), |
| extra: None, |
| with_features: false, |
| } |
| } |
| } |
| |
| pub(crate) struct UnmatchedBypass<'a> { |
| pub(crate) unmatched: &'a super::cfg::ValidBypass, |
| pub(crate) file_id: FileId, |
| } |
| |
| impl<'a> From<UnmatchedBypass<'a>> for Diag { |
| fn from(ubc: UnmatchedBypass<'a>) -> Self { |
| Diagnostic::new(Severity::Warning) |
| .with_message("crate build bypass was not encountered") |
| .with_code(Code::UnmatchedBypass) |
| .with_labels(vec![Label::primary( |
| ubc.file_id, |
| ubc.unmatched.spec.name.span, |
| ) |
| .with_message("unmatched bypass")]) |
| .into() |
| } |
| } |
| |
| pub(crate) struct UnmatchedPathBypass<'a> { |
| pub(crate) unmatched: &'a super::cfg::BypassPath, |
| pub(crate) file_id: FileId, |
| } |
| |
| impl<'a> From<UnmatchedPathBypass<'a>> for Diag { |
| fn from(ua: UnmatchedPathBypass<'a>) -> Self { |
| Diagnostic::new(Severity::Warning) |
| .with_message("allowed path was not encountered") |
| .with_code(Code::UnmatchedPathBypass) |
| .with_labels(vec![Label::primary(ua.file_id, ua.unmatched.path.span)]) |
| .into() |
| } |
| } |
| |
| pub(crate) struct UnmatchedGlob<'a> { |
| pub(crate) unmatched: &'a Spanned<String>, |
| pub(crate) file_id: FileId, |
| } |
| |
| impl<'a> From<UnmatchedGlob<'a>> for Diag { |
| fn from(ug: UnmatchedGlob<'a>) -> Self { |
| Diagnostic::new(Severity::Warning) |
| .with_message("glob was not encountered") |
| .with_code(Code::UnmatchedGlob) |
| .with_labels(vec![Label::primary(ug.file_id, ug.unmatched.span)]) |
| .into() |
| } |
| } |
