Enum yash_syntax::source::Source

source · [−]

#[non_exhaustive]
pub enum Source {
    Unknown,
    Stdin,
    Alias {
        original: Location,
        alias: Rc<Alias>,
    },
    CommandSubst {
        original: Location,
    },
    Trap {
        condition: String,
        origin: Location,
    },
}

Expand description

Origin of source code.

Variants (Non-exhaustive)

This enum is marked as non-exhaustive

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

`Unknown`

Source code of unknown origin.

Normally you should not use this value, but it may be useful for quick debugging.

`Stdin`

Standard input.

`Alias`

Fields

original: Location

Position of the original word that was replaced

alias: Rc<Alias>

Definition of the alias that was substituted

Alias substitution.

This applies to a code fragment that replaced another as a result of alias substitution.

`CommandSubst`

Fields

original: Location

Command substitution.

`Trap`

Fields

condition: String

Trap condition name, typically the signal name.

origin: Location

Location of the simple command that has set this trap command.

Trap command.

Implementations

source

impl Source

source

pub fn complement_annotations<'a, 's: 'a, T: Extend<Annotation<'a>>>(
&'s self,
result: &mut T
)

Appends complementary annotations describing this source.

source

impl Source

source

pub fn is_alias_for(&self, name: &str) -> bool

Tests if this source is alias substitution for the given name.

Returns true if self is Source::Alias with the name or such an original, recursively.

// `is_alias_for` returns false for sources other than an Alias
assert_eq!(Source::Unknown.is_alias_for("foo"), false);

// `is_alias_for` returns true if the names match
let original = Location::dummy("");
let alias = std::rc::Rc::new(yash_syntax::alias::Alias{
    name: "foo".to_string(),
    replacement: "".to_string(),
    global: false,
    origin: original.clone()
});
let source = Source::Alias{original, alias};
assert_eq!(source.is_alias_for("foo"), true);
assert_eq!(source.is_alias_for("bar"), false);

// `is_alias_for` checks aliases recursively.
let mut original = Location::dummy("");
let alias = Rc::new(yash_syntax::alias::Alias{
    name: "foo".to_string(),
    replacement: "".to_string(),
    global: false,
    origin: original.clone()
});
let source = Source::Alias{original: original.clone(), alias};
let alias = Rc::new(yash_syntax::alias::Alias{
    name: "bar".to_string(),
    replacement: "".to_string(),
    global: false,
    origin: original.clone()
});
Rc::make_mut(&mut original.code).source = source;
let source = Source::Alias{original, alias};
assert_eq!(source.is_alias_for("foo"), true);
assert_eq!(source.is_alias_for("bar"), true);
assert_eq!(source.is_alias_for("baz"), false);