Struct syn_solidity::UnicodeStr

pub struct UnicodeStr {
    pub unicode_token: unicode,
    pub value: LitStr,
}

A unicode string.

Fields

unicode_token: unicode

The prefix of the string.

value: LitStr

The string literal.

Methods from Deref<Target = LitStr>

pub fn value(&self) -> String

pub fn parse<T>(&self) -> Result<T, Error>

where T: Parse,

Available on crate feature parsing only.

Parse a syntax tree node from the content of this string literal.

All spans in the syntax tree will point to the span of this LitStr.

Example

use syn::{Attribute, Error, Expr, Lit, Meta, Path, Result};

// Parses the path from an attribute that looks like:
//
//     #[path = "a::b::c"]
//
// or returns `None` if the input is some other attribute.
fn get_path(attr: &Attribute) -> Result<Option<Path>> {
    if !attr.path().is_ident("path") {
        return Ok(None);
    }

    if let Meta::NameValue(meta) = &attr.meta {
        if let Expr::Lit(expr) = &meta.value {
            if let Lit::Str(lit_str) = &expr.lit {
                return lit_str.parse().map(Some);
            }
        }
    }

    let message = "expected #[path = \"...\"]";
    Err(Error::new_spanned(attr, message))
}

pub fn parse_with<F>(&self, parser: F) -> Result<<F as Parser>::Output, Error>

where F: Parser,

Available on crate feature parsing only.

Invoke parser on the content of this string literal.

All spans in the syntax tree will point to the span of this LitStr.

Example

let lit_str: LitStr = /* ... */;

// Parse a string literal like "a::b::c" into a Path, not allowing
// generic arguments on any of the path segments.
let basic_path = lit_str.parse_with(syn::Path::parse_mod_style)?;

pub fn span(&self) -> Span

pub fn set_span(&mut self, span: Span)

pub fn suffix(&self) -> &str

pub fn token(&self) -> Literal

Trait Implementations

impl Clone for UnicodeStr

fn clone(&self) -> UnicodeStr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UnicodeStr

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

Formats the value using the given formatter.

impl Deref for UnicodeStr

type Target = LitStr

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for UnicodeStr

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Parse for UnicodeStr

fn parse(input: ParseStream<'_>) -> Result<Self>

impl Spanned for UnicodeStr

fn span(&self) -> Span

Returns a Span covering the complete contents of this syntax tree node, or Span::call_site() if this node is empty.

fn set_span(&mut self, span: Span)

Sets the span of this syntax tree node if it is not empty.

fn with_span(self, span: Span) -> Self

where Self: Sized,

Sets the span of this owned syntax tree node if it is not empty.