Struct erg_compiler::error::CompileError

pub struct CompileError {
    pub core: ErrorCore,
    pub input: Input,
    pub caused_by: Str,
}

Fields

core: ErrorCore

input: Input

caused_by: Str

Implementations

impl CompileError

pub const fn new(core: ErrorCore, input: Input, caused_by: Str) -> Self

pub fn compiler_bug(
    errno: usize,
    input: Input,
    loc: Location,
    fn_name: &str,
    line: u32
) -> Self

pub fn stack_bug(
    input: Input,
    loc: Location,
    stack_len: u32,
    block_id: usize,
    fn_name: &str
) -> Self

pub fn feature_error(
    input: Input,
    loc: Location,
    name: &str,
    caused_by: Str
) -> Self

Trait Implementations

impl Debug for CompileError

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

Formats the value using the given formatter.

impl ErrorDisplay for CompileError

fn core(&self) -> &ErrorCore

fn input(&self) -> &Input

fn caused_by(&self) -> &str

The block name the error caused. This will be None if the error occurred before semantic analysis. As for the internal error, do not put the fn name here.

fn ref_inner(&self) -> Option<&Box<Self>>

the previous error that caused this error.

fn write_to_stderr(&self)

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

fmt::Display実装用

fn format_header(&self) -> String

fn format_code_and_pointer(&self) -> String

impl From<CompileError> for CompileErrors

fn from(err: CompileError) -> Self

Converts to this type from the input type.

impl From<ParserRunnerError> for CompileError

fn from(err: ParserRunnerError) -> Self

Converts to this type from the input type.

impl MultiErrorDisplay<CompileError> for CompileErrors

fn fmt_all_stderr(&self)

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

impl Stream<CompileError> for CompileErrors

fn payload(self) -> Vec<CompileError>

fn ref_payload(&self) -> &Vec<CompileError>

fn ref_mut_payload(&mut self) -> &mut Vec<CompileError>

fn clear(&mut self)

fn len(&self) -> usize

fn size(&self) -> usize

fn is_empty(&self) -> bool

fn insert(&mut self, idx: usize, elem: T)

fn remove(&mut self, idx: usize) -> T

fn push(&mut self, elem: T)

fn append<S>(&mut self, s: &mut S) where
    S: Stream<T>, 

fn pop(&mut self) -> Option<T>

fn lpop(&mut self) -> Option<T>

fn get(&self, idx: usize) -> Option<&T>

fn get_mut(&mut self, idx: usize) -> Option<&mut T>

fn first(&self) -> Option<&T>

fn first_mut(&mut self) -> Option<&mut T>

fn last(&self) -> Option<&T>

fn last_mut(&mut self) -> Option<&mut T>

fn iter(&self) -> Iter<'_, T>

fn iter_mut(&mut self) -> IterMut<'_, T>

fn into_iter(self) -> IntoIter<T, Global>

fn take_all(&mut self) -> Vec<T, Global>