Struct ParseFlags 

pub struct ParseFlags {
    pub parse_flow: bool,
    pub parse_flow_component_syntax: bool,
    pub parse_flow_records: bool,
    pub parse_flow_match: bool,
    pub parse_ts: bool,
    pub parse_jsx: bool,
    pub strict_mode: bool,
}

Which dialect(s) the parser accepts, plus forced strict mode.

Default is plain ECMAScript, non-strict — every flag false. Each field maps to the identically-named hermes_ast::context::Context flag, which is where the parser reads it from; the C++ Context getters cited in that module are the authoritative semantics. Two fields set more than their own flag, as documented below.

use hermes_parser::ParseFlags;
let flags = ParseFlags { parse_flow: true, ..Default::default() };

Fields

parse_flow: bool

Parse the Flow type grammar (hermesc -parse-flow).

This also enables the Flow ambiguous-expression grammar (typed arrows, as, type-args on call/new, type casts), because hermesc’s -parse-flow means ParseFlowSetting::ALL. Flow and TypeScript are mutually exclusive dialects: do not set this together with Self::parse_ts.

parse_flow_component_syntax: bool

Parse Flow component/hook declarations (hermesc -Xparse-component-syntax). Implies Self::parse_flow.

parse_flow_records: bool

Parse Flow record declarations and expressions (hermesc -Xparse-flow-records). Implies Self::parse_flow.

parse_flow_match: bool

Parse Flow match expressions and statements (hermesc -Xparse-flow-match). Implies Self::parse_flow.

parse_ts: bool

Parse the TypeScript type grammar (hermesc -parse-ts). Mutually exclusive with Self::parse_flow and its extensions.

parse_jsx: bool

Parse JSX (hermesc -parse-jsx). Independent of the type dialect: combines with Flow, with TypeScript, or with neither. Note that enabling JSX disables the TypeScript <Type>expr assertion grammar, exactly as in the C++ parser.

strict_mode: bool

Force strict mode for the whole source, as if it began with a "use strict" directive. Sets Context::enable_strict_mode.

Trait Implementations

impl Clone for ParseFlags

fn clone(&self) -> ParseFlags

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ParseFlags

impl Debug for ParseFlags

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

Formats the value using the given formatter.

impl Default for ParseFlags

fn default() -> ParseFlags

Returns the “default value” for a type.

impl Eq for ParseFlags

impl PartialEq for ParseFlags

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ParseFlags