Enum Concern

pub enum Concern {
    LintWarning(Warning),
    ParseError(Error),
    ValidationFailure(Failure),
}

A concern.

A concern is defined as any information that is important to interpretting a returned parse or abstract syntax tree. There are three classes of concerns that can be returned:

• Parse errors, which are errors that are return by Pest during the building of the parse tree.
• Validation failures, which are error that are occur when validating a parse tree or abstract syntax tree.
• Lint warnings, which are notifications about syntactically and semantically correct code that is otherwise notable, such as stylistic errors, programming mistakes, or deviations from best practices.

Variants

LintWarning(Warning)

A lint warning.

ParseError(Error)

A parse error.

ValidationFailure(Failure)

A validation failure.

Implementations

impl Concern

pub fn as_lint_warning(&self) -> Option<&Warning>

Returns [Some(&lint::Warning)] if the Concern is a lint::Warning. Otherwise, returns None.

Examples

use wdl_core::concern::code::Kind;
use wdl_core::concern::lint;
use wdl_core::concern::lint::Level;
use wdl_core::concern::lint::TagSet;
use wdl_core::concern::parse;
use wdl_core::concern::validation;
use wdl_core::concern::Code;
use wdl_core::file::Location;
use wdl_core::Concern;
use wdl_core::Version;

let error = parse::Error::new("Hello, world!", Location::Unplaced);
let concern = Concern::ParseError(error);
assert!(concern.as_lint_warning().is_none());

let failure = validation::failure::Builder::default()
    .code(Code::try_new(Kind::Error, Version::V1, 1)?)
    .push_location(Location::Unplaced)
    .subject("Hello, world!")
    .body("A body.")
    .fix("How to fix the issue.")
    .try_build()?;

let concern = Concern::ValidationFailure(failure);
assert!(concern.as_lint_warning().is_none());

let warning = lint::warning::Builder::default()
    .code(Code::try_new(Kind::Warning, Version::V1, 1)?)
    .level(Level::High)
    .tags(TagSet::new(&[lint::Tag::Style]))
    .push_location(Location::Unplaced)
    .subject("Hello, world!")
    .body("A body.")
    .fix("How to fix the issue.")
    .try_build()?;

let concern = Concern::LintWarning(warning);
assert!(concern.as_lint_warning().is_some());

pub fn into_lint_warning(self) -> Option<Warning>

Consumes self and returns [Some(lint::Warning)] if the Concern is a lint::Warning. Otherwise, returns None.

Examples

use wdl_core::concern::code::Kind;
use wdl_core::concern::lint;
use wdl_core::concern::lint::Level;
use wdl_core::concern::lint::TagSet;
use wdl_core::concern::parse;
use wdl_core::concern::validation;
use wdl_core::concern::Code;
use wdl_core::file::Location;
use wdl_core::Concern;
use wdl_core::Version;

let error = parse::Error::new("Hello, world!", Location::Unplaced);
let concern = Concern::ParseError(error);
assert!(concern.into_lint_warning().is_none());

let failure = validation::failure::Builder::default()
    .code(Code::try_new(Kind::Error, Version::V1, 1)?)
    .push_location(Location::Unplaced)
    .subject("Hello, world!")
    .body("A body.")
    .fix("How to fix the issue.")
    .try_build()?;

let concern = Concern::ValidationFailure(failure);
assert!(concern.into_lint_warning().is_none());

let warning = lint::warning::Builder::default()
    .code(Code::try_new(Kind::Warning, Version::V1, 1)?)
    .level(Level::High)
    .tags(TagSet::new(&[lint::Tag::Style]))
    .push_location(Location::Unplaced)
    .subject("Hello, world!")
    .body("A body.")
    .fix("How to fix the issue.")
    .try_build()?;

let concern = Concern::LintWarning(warning);
assert!(concern.into_lint_warning().is_some());

pub fn as_validation_failure(&self) -> Option<&Failure>

Returns [Some(&validation::Failure)] if the Concern is a validation::Failure. Otherwise, returns None.

Examples

use wdl_core::concern::code::Kind;
use wdl_core::concern::lint;
use wdl_core::concern::lint::Level;
use wdl_core::concern::lint::TagSet;
use wdl_core::concern::parse;
use wdl_core::concern::validation;
use wdl_core::concern::Code;
use wdl_core::file::Location;
use wdl_core::Concern;
use wdl_core::Version;

let error = parse::Error::new("Hello, world!", Location::Unplaced);
let concern = Concern::ParseError(error);
assert!(concern.as_validation_failure().is_none());

let failure = validation::failure::Builder::default()
    .code(Code::try_new(Kind::Error, Version::V1, 1)?)
    .push_location(Location::Unplaced)
    .subject("Hello, world!")
    .body("A body.")
    .fix("How to fix the issue.")
    .try_build()?;

let concern = Concern::ValidationFailure(failure);
assert!(concern.as_validation_failure().is_some());

let warning = lint::warning::Builder::default()
    .code(Code::try_new(Kind::Warning, Version::V1, 1)?)
    .level(Level::High)
    .tags(TagSet::new(&[lint::Tag::Style]))
    .push_location(Location::Unplaced)
    .subject("Hello, world!")
    .body("A body.")
    .fix("How to fix the issue.")
    .try_build()?;

let concern = Concern::LintWarning(warning);
assert!(concern.as_validation_failure().is_none());

pub fn into_validation_failure(self) -> Option<Failure>

Consumes self and returns [Some(validation::Failure)] if the Concern is a validation::Failure. Otherwise, returns None.

Examples

use wdl_core::concern::code::Kind;
use wdl_core::concern::lint;
use wdl_core::concern::lint::Level;
use wdl_core::concern::lint::TagSet;
use wdl_core::concern::parse;
use wdl_core::concern::validation;
use wdl_core::concern::Code;
use wdl_core::file::Location;
use wdl_core::Concern;
use wdl_core::Version;

let error = parse::Error::new("Hello, world!", Location::Unplaced);
let concern = Concern::ParseError(error);
assert!(concern.into_validation_failure().is_none());

let failure = validation::failure::Builder::default()
    .code(Code::try_new(Kind::Error, Version::V1, 1)?)
    .push_location(Location::Unplaced)
    .subject("Hello, world!")
    .body("A body.")
    .fix("How to fix the issue.")
    .try_build()?;

let concern = Concern::ValidationFailure(failure);
assert!(concern.into_validation_failure().is_some());

let warning = lint::warning::Builder::default()
    .code(Code::try_new(Kind::Warning, Version::V1, 1)?)
    .level(Level::High)
    .tags(TagSet::new(&[lint::Tag::Style]))
    .push_location(Location::Unplaced)
    .subject("Hello, world!")
    .body("A body.")
    .fix("How to fix the issue.")
    .try_build()?;

let concern = Concern::LintWarning(warning);
assert!(concern.into_validation_failure().is_none());

pub fn as_parse_error(&self) -> Option<&Error>

Returns [Some(&parse::Error)] if the Concern is a parse::Error. Otherwise, returns None.

Examples

use wdl_core::concern::code::Kind;
use wdl_core::concern::lint;
use wdl_core::concern::lint::Level;
use wdl_core::concern::lint::TagSet;
use wdl_core::concern::parse;
use wdl_core::concern::validation;
use wdl_core::concern::Code;
use wdl_core::file::Location;
use wdl_core::Concern;
use wdl_core::Version;

let error = parse::Error::new("Hello, world!", Location::Unplaced);
let concern = Concern::ParseError(error);
assert!(concern.as_parse_error().is_some());

let failure = validation::failure::Builder::default()
    .code(Code::try_new(Kind::Error, Version::V1, 1)?)
    .push_location(Location::Unplaced)
    .subject("Hello, world!")
    .body("A body.")
    .fix("How to fix the issue.")
    .try_build()?;

let concern = Concern::ValidationFailure(failure);
assert!(concern.as_parse_error().is_none());

let warning = lint::warning::Builder::default()
    .code(Code::try_new(Kind::Warning, Version::V1, 1)?)
    .level(Level::High)
    .tags(TagSet::new(&[lint::Tag::Style]))
    .push_location(Location::Unplaced)
    .subject("Hello, world!")
    .body("A body.")
    .fix("How to fix the issue.")
    .try_build()?;

let concern = Concern::LintWarning(warning);
assert!(concern.as_parse_error().is_none());

pub fn into_parse_error(self) -> Option<Error>

Consumes self and returns [Some(parse::Error)] if the Concern is a parse::Error. Otherwise, returns None.

Examples

use wdl_core::concern::code::Kind;
use wdl_core::concern::lint;
use wdl_core::concern::lint::Level;
use wdl_core::concern::lint::TagSet;
use wdl_core::concern::parse;
use wdl_core::concern::validation;
use wdl_core::concern::Code;
use wdl_core::file::Location;
use wdl_core::Concern;
use wdl_core::Version;

let error = parse::Error::new("Hello, world!", Location::Unplaced);
let concern = Concern::ParseError(error);
assert!(concern.into_parse_error().is_some());

let failure = validation::failure::Builder::default()
    .code(Code::try_new(Kind::Error, Version::V1, 1)?)
    .push_location(Location::Unplaced)
    .subject("Hello, world!")
    .body("A body.")
    .fix("How to fix the issue.")
    .try_build()?;

let concern = Concern::ValidationFailure(failure);
assert!(concern.into_parse_error().is_none());

let warning = lint::warning::Builder::default()
    .code(Code::try_new(Kind::Warning, Version::V1, 1)?)
    .level(Level::High)
    .tags(TagSet::new(&[lint::Tag::Style]))
    .push_location(Location::Unplaced)
    .subject("Hello, world!")
    .body("A body.")
    .fix("How to fix the issue.")
    .try_build()?;

let concern = Concern::LintWarning(warning);
assert!(concern.into_parse_error().is_none());

Trait Implementations

impl Clone for Concern

fn clone(&self) -> Concern

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Concern

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Concern

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Concern

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Concern

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Concern

fn cmp(&self, other: &Concern) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Concern

fn eq(&self, other: &Concern) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Concern

fn partial_cmp(&self, other: &Concern) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Concern

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Concern

impl StructuralPartialEq for Concern