Struct PragmaState 

pub struct PragmaState {

    pub strict_vars: bool,
    pub strict_subs: bool,
    pub strict_refs: bool,
    pub warnings: bool,
    pub utf8: bool,
    pub encoding: Option<String>,
    pub unicode_strings: bool,
    pub locale: bool,
    pub locale_scope: Option<String>,
    pub disabled_warning_categories: Vec<String>,
    pub signatures_strict: bool,
    pub features: Vec<&'static str>,
    pub builtin_imports: Vec<String>,
}

Pragma state at a given point in the code

Fields

strict_vars: bool

Whether strict vars is enabled

strict_subs: bool

Whether strict subs is enabled

strict_refs: bool

Whether strict refs is enabled

warnings: bool

Whether warnings are enabled (globally)

utf8: bool

Whether use utf8 is enabled.

encoding: Option<String>

Active source encoding from use encoding.

unicode_strings: bool

Whether use feature 'unicode_strings' or a matching feature bundle is enabled.

locale: bool

Whether locale-sensitive behavior is enabled.

locale_scope: Option<String>

Locale scope from use locale, if any.

disabled_warning_categories: Vec<String>

Warning categories explicitly disabled via no warnings 'CATEGORY'.

When no warnings is used with specific category arguments (e.g. no warnings 'uninitialized'), the global warnings flag stays true and the disabled categories are recorded here. Only bare no warnings (no arguments) clears the global warnings flag.

signatures_strict: bool

Whether explicit use feature 'signatures' currently implies strictness.

This is tracked separately from the raw strict flags so no feature 'signatures' can unwind the feature-driven implication without clobbering explicit use strict or version-implied strict state.

features: Vec<&'static str>

Effective language features enabled in the current lexical scope.

This starts with any features implied by use vX.Y declarations and is then updated by explicit use feature / no feature pragmas.

builtin_imports: Vec<String>

Lexically imported builtin short names from use builtin.

Implementations

impl PragmaState

pub fn all_strict() -> PragmaState

Create a new pragma state with all strict modes enabled

pub fn is_warning_active(&self, category: &str) -> bool

Returns true if warnings are active for the given category.

Warnings for a category are active when:

• The global warnings flag is true, and
• The category is not listed in disabled_warning_categories.

If the global warnings flag is false (i.e. no warnings with no arguments was used), all categories are considered inactive regardless of the disabled_warning_categories list.

pub fn has_feature(&self, feature: &str) -> bool

Returns true if the given feature name is currently enabled.

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

Returns true when a builtin short name was lexically imported in scope.

Trait Implementations

impl Clone for PragmaState

fn clone(&self) -> PragmaState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PragmaState

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

Formats the value using the given formatter.

impl Default for PragmaState

fn default() -> PragmaState

Returns the “default value” for a type.

impl From<PragmaSnapshot> for PragmaState

fn from(snapshot: PragmaSnapshot) -> PragmaState

Converts to this type from the input type.

impl From<PragmaState> for PragmaSnapshot

fn from(state: PragmaState) -> PragmaSnapshot

Converts to this type from the input type.

impl PartialEq for PragmaState

fn eq(&self, other: &PragmaState) -> 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 StructuralPartialEq for PragmaState