Struct swc_common::SourceFile

pub struct SourceFile {
    pub name: FileName,
    pub name_was_remapped: bool,
    pub unmapped_path: Option<FileName>,
    pub crate_of_origin: u32,
    pub src: Lrc<String>,
    pub src_hash: u128,
    pub start_pos: BytePos,
    pub end_pos: BytePos,
    pub lines: Vec<BytePos>,
    pub multibyte_chars: Vec<MultiByteChar>,
    pub non_narrow_chars: Vec<NonNarrowChar>,
    pub name_hash: u128,
}

A single source in the SourceMap.

Fields

name: FileName

The name of the file that the source came from. Source that doesn’t originate from files has names between angle brackets by convention, e.g. <anon>

name_was_remapped: bool

True if the name field above has been modified by --remap-path-prefix

unmapped_path: Option<FileName>

The unmapped path of the file that the source came from. Set to None if the SourceFile was imported from an external crate.

crate_of_origin: u32

Indicates which crate this SourceFile was imported from.

src: Lrc<String>

The complete source code

src_hash: u128

The source code’s hash

start_pos: BytePos

The start position of this source in the SourceMap

end_pos: BytePos

The end position of this source in the SourceMap

lines: Vec<BytePos>

Locations of lines beginnings in the source code

multibyte_chars: Vec<MultiByteChar>

Locations of multi-byte characters in the source code

non_narrow_chars: Vec<NonNarrowChar>

Width of characters that are not narrow in the source code

name_hash: u128

A hash of the filename, used for speeding up the incr. comp. hashing.

Implementations

impl SourceFile

pub fn new(
    name: FileName,
    name_was_remapped: bool,
    unmapped_path: FileName,
    src: String,
    start_pos: BytePos
) -> SourceFile

pub fn line_begin_pos(&self, pos: BytePos) -> BytePos

Return the BytePos of the beginning of the current line.

pub fn get_line(&self, line_number: usize) -> Option<Cow<'_, str>>

Get a line from the list of pre-computed line-beginnings. The line number here is 0-based.

pub fn is_real_file(&self) -> bool

pub fn byte_length(&self) -> u32

pub fn count_lines(&self) -> usize

pub fn lookup_line(&self, pos: BytePos) -> Option<usize>

Find the line containing the given position. The return value is the index into the lines array of this SourceFile, not the 1-based line number. If the source_file is empty or the position is located before the first line, None is returned.

pub fn line_bounds(&self, line_index: usize) -> (BytePos, BytePos)

pub fn contains(&self, byte_pos: BytePos) -> bool

Trait Implementations

impl Archive for SourceFile where
    FileName: Archive,
    bool: Archive,
    Option<FileName>: Archive,
    u32: Archive,
    Lrc<String>: Archive,
    u128: Archive,
    BytePos: Archive,
    BytePos: Archive,
    Vec<BytePos>: Archive,
    Vec<MultiByteChar>: Archive,
    Vec<NonNarrowChar>: Archive,
    u128: Archive, 

type Archived = ArchivedSourceFile

The archived representation of this type.

type Resolver = SourceFileResolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve(
    &self,
    pos: usize,
    resolver: Self::Resolver,
    out: *mut Self::Archived
)

Creates the archived version of this value at the given position and writes it to the given output.

impl Clone for SourceFile

fn clone(&self) -> SourceFile

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SourceFile

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

Formats the value using the given formatter.

impl<__D: Fallible + ?Sized> Deserialize<SourceFile, __D> for Archived<SourceFile> where
    FileName: Archive,
    Archived<FileName>: Deserialize<FileName, __D>,
    bool: Archive,
    Archived<bool>: Deserialize<bool, __D>,
    Option<FileName>: Archive,
    Archived<Option<FileName>>: Deserialize<Option<FileName>, __D>,
    u32: Archive,
    Archived<u32>: Deserialize<u32, __D>,
    Lrc<String>: Archive,
    Archived<Lrc<String>>: Deserialize<Lrc<String>, __D>,
    u128: Archive,
    Archived<u128>: Deserialize<u128, __D>,
    BytePos: Archive,
    Archived<BytePos>: Deserialize<BytePos, __D>,
    BytePos: Archive,
    Archived<BytePos>: Deserialize<BytePos, __D>,
    Vec<BytePos>: Archive,
    Archived<Vec<BytePos>>: Deserialize<Vec<BytePos>, __D>,
    Vec<MultiByteChar>: Archive,
    Archived<Vec<MultiByteChar>>: Deserialize<Vec<MultiByteChar>, __D>,
    Vec<NonNarrowChar>: Archive,
    Archived<Vec<NonNarrowChar>>: Deserialize<Vec<NonNarrowChar>, __D>,
    u128: Archive,
    Archived<u128>: Deserialize<u128, __D>, 

fn deserialize(&self, deserializer: &mut __D) -> Result<SourceFile, __D::Error>

Deserializes using the given deserializer

impl<'a> From<&'a SourceFile> for StringInput<'a>

Creates an Input from SourceFile. This is an alias for

   StringInput::new(&fm.src, fm.start_pos, fm.end_pos)

fn from(fm: &'a SourceFile) -> Self

Converts to this type from the input type.

impl<__S: Fallible + ?Sized> Serialize<__S> for SourceFile where
    FileName: Serialize<__S>,
    bool: Serialize<__S>,
    Option<FileName>: Serialize<__S>,
    u32: Serialize<__S>,
    Lrc<String>: Serialize<__S>,
    u128: Serialize<__S>,
    BytePos: Serialize<__S>,
    BytePos: Serialize<__S>,
    Vec<BytePos>: Serialize<__S>,
    Vec<MultiByteChar>: Serialize<__S>,
    Vec<NonNarrowChar>: Serialize<__S>,
    u128: Serialize<__S>, 

fn serialize(&self, serializer: &mut __S) -> Result<Self::Resolver, __S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.