syntect/parsing/
scope.rs

Help
1// see DESIGN.md
2use std::collections::HashMap;
3use std::u16;
4use std::sync::Mutex;
5use std::fmt;
6use std::str::FromStr;
7use std::u64;
8use std::cmp::{Ordering, min};
9use std::mem;
10
11use once_cell::sync::Lazy;
12use serde::de::{Deserialize, Deserializer, Error, Visitor};
13use serde::ser::{Serialize, Serializer};
14use serde_derive::{Deserialize, Serialize};
15
16/// Scope related errors
17#[derive(Debug, thiserror::Error)]
18#[non_exhaustive]
19pub enum ScopeError {
20    #[error("Tried to restore cleared scopes, but none were cleared")]
21    NoClearedScopesToRestore,
22}
23
24/// Multiplier on the power of 2 for MatchPower. This is only useful if you compute your own
25/// [`MatchPower`] scores
26///
27/// [`MatchPower`]: struct.MatchPower.html
28pub const ATOM_LEN_BITS: u16 = 3;
29
30/// The global scope repo, exposed in case you want to minimize locking and unlocking.
31///
32/// Ths shouldn't be necessary for you to use. See the [`ScopeRepository`] docs.
33///
34/// [`ScopeRepository`]: struct.ScopeRepository.html
35pub static SCOPE_REPO: Lazy<Mutex<ScopeRepository>> =
36    Lazy::new(|| Mutex::new(ScopeRepository::new()));
37
38
39/// A hierarchy of atoms with semi-standardized names used to accord semantic information to a
40/// specific piece of text.
41///
42/// These are generally written with the atoms separated by dots, and - by convention - atoms are
43/// all lowercase alphanumeric.
44///
45/// Example scopes: `text.plain`, `punctuation.definition.string.begin.ruby`,
46/// `meta.function.parameters.rust`
47///
48/// `syntect` uses an optimized format for storing these that allows super fast comparison and
49/// determining if one scope is a prefix of another. It also always takes 16 bytes of space. It
50/// accomplishes this by using a global repository to store string values and using bit-packed 16
51/// bit numbers to represent and compare atoms. Like "atoms" or "symbols" in other languages. This
52/// means that while comparing and prefix are fast, extracting a string is relatively slower but
53/// ideally should be very rare.
54#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Copy, Default, Hash)]
55pub struct Scope {
56    a: u64,
57    b: u64,
58}
59
60/// Not all strings are valid scopes
61#[derive(Debug, thiserror::Error)]
62#[non_exhaustive]
63pub enum ParseScopeError {
64    /// Due to a limitation of the current optimized internal representation
65    /// scopes can be at most 8 atoms long
66    #[error("Too long scope. Scopes can be at most 8 atoms long.")]
67    TooLong,
68    /// The internal representation uses 16 bits per atom, so if all scopes ever
69    /// used by the program have more than 2^16-2 atoms, things break
70    #[error("Too many atoms. Max 2^16-2 atoms allowed.")]
71    TooManyAtoms,
72}
73
74/// The structure used to keep track of the mapping between scope atom numbers and their string
75/// names
76///
77/// It is only exposed in case you want to lock [`SCOPE_REPO`] and then allocate a bunch of scopes
78/// at once without thrashing the lock. In general, you should just use [`Scope::new()`].
79///
80/// Only [`Scope`]s created by the same repository have valid comparison results.
81///
82/// [`SCOPE_REPO`]: struct.SCOPE_REPO.html
83/// [`Scope::new()`]: struct.Scope.html#method.new
84/// [`Scope`]: struct.Scope.html
85#[derive(Debug)]
86pub struct ScopeRepository {
87    atoms: Vec<String>,
88    atom_index_map: HashMap<String, usize>,
89}
90
91/// A stack/sequence of scopes for representing hierarchies for a given token of text
92///
93/// This is also used within [`ScopeSelectors`].
94///
95/// In Sublime Text, the scope stack at a given point can be seen by pressing `ctrl+shift+p`. Also
96/// see [the TextMate docs](https://manual.macromates.com/en/scope_selectors).
97///
98/// Example for a JS string inside a script tag in a Rails `ERB` file:
99/// `text.html.ruby text.html.basic source.js.embedded.html string.quoted.double.js`
100///
101/// [`ScopeSelectors`]: ../highlighting/struct.ScopeSelectors.html
102#[derive(Debug, Clone, PartialEq, Eq, Default, Serialize, Deserialize)]
103pub struct ScopeStack {
104    clear_stack: Vec<Vec<Scope>>,
105    pub scopes: Vec<Scope>,
106}
107
108#[derive(Debug, Clone, Copy, Eq, PartialEq, Serialize, Deserialize)]
109pub enum ClearAmount {
110    TopN(usize),
111    All,
112}
113
114/// A change to a scope stack
115///
116/// Generally, `Noop` is only used internally and you won't need to worry about getting one back
117/// from calling a public function.
118///
119/// The change from a `ScopeStackOp` can be applied via [`ScopeStack::apply`].
120///
121/// [`ScopeStack::apply`]: struct.ScopeStack.html#method.apply
122#[derive(Debug, Clone, PartialEq, Eq)]
123pub enum ScopeStackOp {
124    Push(Scope),
125    Pop(usize),
126    /// Used for the `clear_scopes` feature
127    Clear(ClearAmount),
128    /// Restores cleared scopes
129    Restore,
130    Noop,
131}
132
133/// Used for [`ScopeStack::apply_with_hook`]
134///
135/// [`ScopeStack::apply_with_hook`]: struct.ScopeStack.html#method.apply_with_hook
136#[derive(Debug, Clone, PartialEq, Eq)]
137pub enum BasicScopeStackOp {
138    Push(Scope),
139    Pop,
140}
141
142fn pack_as_u16s(atoms: &[usize]) -> Result<Scope, ParseScopeError> {
143    let mut res = Scope { a: 0, b: 0 };
144
145    for (i, &n) in atoms.iter().enumerate() {
146        if n >= (u16::MAX as usize) - 2 {
147            return Err(ParseScopeError::TooManyAtoms);
148        }
149        let small = (n + 1) as u64; // +1 since we reserve 0 for unused
150
151        if i < 4 {
152            let shift = (3 - i) * 16;
153            res.a |= small << shift;
154        } else {
155            let shift = (7 - i) * 16;
156            res.b |= small << shift;
157        }
158    }
159    Ok(res)
160}
161
162impl ScopeRepository {
163    fn new() -> ScopeRepository {
164        ScopeRepository {
165            atoms: Vec::new(),
166            atom_index_map: HashMap::new(),
167        }
168    }
169
170    pub fn build(&mut self, s: &str) -> Result<Scope, ParseScopeError> {
171        if s.is_empty() {
172            return Ok(Scope { a: 0, b: 0 });
173        }
174        let parts: Vec<usize> = s.trim_end_matches('.').split('.').map(|a| self.atom_to_index(a)).collect();
175        if parts.len() > 8 {
176            return Err(ParseScopeError::TooManyAtoms);
177        }
178        pack_as_u16s(&parts[..])
179    }
180
181    pub fn to_string(&self, scope: Scope) -> String {
182        let mut s = String::new();
183        for i in 0..8 {
184            let atom_number = scope.atom_at(i);
185            // println!("atom {} of {:x}-{:x} = {:x}",
186            //     i, scope.a, scope.b, atom_number);
187            if atom_number == 0 {
188                break;
189            }
190            if i != 0 {
191                s.push('.');
192            }
193            s.push_str(self.atom_str(atom_number));
194        }
195        s
196    }
197
198    fn atom_to_index(&mut self, atom: &str) -> usize {
199        if let Some(index) = self.atom_index_map.get(atom) {
200            return *index;
201        }
202
203        self.atoms.push(atom.to_owned());
204        let index = self.atoms.len() - 1;
205        self.atom_index_map.insert(atom.to_owned(), index);
206
207        index
208    }
209
210    /// Return the string for an atom number returned by [`Scope::atom_at`]
211    ///
212    /// [`Scope::atom_at`]: struct.Scope.html#method.atom_at
213    pub fn atom_str(&self, atom_number: u16) -> &str {
214        &self.atoms[(atom_number - 1) as usize]
215    }
216}
217
218impl Scope {
219    /// Parses a `Scope` from a series of atoms separated by dot (`.`) characters
220    ///
221    /// Example: `Scope::new("meta.rails.controller")`
222    pub fn new(s: &str) -> Result<Scope, ParseScopeError> {
223        let mut repo = SCOPE_REPO.lock().unwrap();
224        repo.build(s.trim())
225    }
226
227    /// Gets the atom number at a given index.
228    ///
229    /// I can't think of any reason you'd find this useful. It is used internally for turning a
230    /// scope back into a string.
231    pub fn atom_at(self, index: usize) -> u16 {
232        #[allow(clippy::panic)] // The below panic is too much of an edge-case for it to be worth propagating
233        let shifted = if index < 4 {
234            self.a >> ((3 - index) * 16)
235        } else if index < 8 {
236            self.b >> ((7 - index) * 16)
237        } else {
238            panic!("atom index out of bounds {:?}", index);
239        };
240        (shifted & 0xFFFF) as u16
241    }
242
243    #[inline]
244    fn missing_atoms(self) -> u32 {
245        let trail = if self.b == 0 {
246            self.a.trailing_zeros() + 64
247        } else {
248            self.b.trailing_zeros()
249        };
250        trail / 16
251    }
252
253    /// Returns the number of atoms in the scope
254    #[inline(always)]
255    pub fn len(self) -> u32 {
256        8 - self.missing_atoms()
257    }
258
259    pub fn is_empty(self) -> bool {
260        self.len() == 0
261    }
262
263    /// Returns a string representation of this scope
264    ///
265    /// This requires locking a global repo and shouldn't be done frequently.
266    pub fn build_string(self) -> String {
267        let repo = SCOPE_REPO.lock().unwrap();
268        repo.to_string(self)
269    }
270
271    /// Tests if this scope is a prefix of another scope. Note that the empty scope is always a
272    /// prefix.
273    ///
274    /// This operation uses bitwise operations and is very fast
275    /// # Examples
276    ///
277    /// ```
278    /// use syntect::parsing::Scope;
279    /// assert!( Scope::new("string").unwrap()
280    ///         .is_prefix_of(Scope::new("string.quoted").unwrap()));
281    /// assert!( Scope::new("string.quoted").unwrap()
282    ///         .is_prefix_of(Scope::new("string.quoted").unwrap()));
283    /// assert!( Scope::new("").unwrap()
284    ///         .is_prefix_of(Scope::new("meta.rails.controller").unwrap()));
285    /// assert!(!Scope::new("source.php").unwrap()
286    ///         .is_prefix_of(Scope::new("source").unwrap()));
287    /// assert!(!Scope::new("source.php").unwrap()
288    ///         .is_prefix_of(Scope::new("source.ruby").unwrap()));
289    /// assert!(!Scope::new("meta.php").unwrap()
290    ///         .is_prefix_of(Scope::new("source.php").unwrap()));
291    /// assert!(!Scope::new("meta.php").unwrap()
292    ///         .is_prefix_of(Scope::new("source.php.wow").unwrap()));
293    /// ```
294    pub fn is_prefix_of(self, s: Scope) -> bool {
295        let pref_missing = self.missing_atoms();
296
297        // TODO: test optimization - use checked shl and then mult carry flag as int by -1
298        let mask: (u64, u64) = if pref_missing == 8 {
299            (0, 0)
300        } else if pref_missing == 4 {
301            (u64::MAX, 0)
302        } else if pref_missing > 4 {
303            (u64::MAX << ((pref_missing - 4) * 16), 0)
304        } else {
305            (u64::MAX, u64::MAX << (pref_missing * 16))
306        };
307
308        // xor to find the difference
309        let ax = (self.a ^ s.a) & mask.0;
310        let bx = (self.b ^ s.b) & mask.1;
311        // println!("{:x}-{:x} is_pref {:x}-{:x}: missing {} mask {:x}-{:x} xor {:x}-{:x}",
312        //     self.a, self.b, s.a, s.b, pref_missing, mask.0, mask.1, ax, bx);
313
314        ax == 0 && bx == 0
315    }
316}
317
318impl FromStr for Scope {
319    type Err = ParseScopeError;
320
321    fn from_str(s: &str) -> Result<Scope, ParseScopeError> {
322        Scope::new(s)
323    }
324}
325
326impl fmt::Display for Scope {
327    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
328        let s = self.build_string();
329        write!(f, "{}", s)
330    }
331}
332
333impl fmt::Debug for Scope {
334    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
335        let s = self.build_string();
336        write!(f, "<{}>", s)
337    }
338}
339
340impl Serialize for Scope {
341    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
342        let s = self.build_string();
343        serializer.serialize_str(&s)
344    }
345}
346
347impl<'de> Deserialize<'de> for Scope {
348    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de> {
349
350        struct ScopeVisitor;
351
352        impl<'de> Visitor<'de> for ScopeVisitor {
353            type Value = Scope;
354
355            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
356                formatter.write_str("a string")
357            }
358
359            fn visit_str<E>(self, v: &str) -> Result<Scope, E> where E: Error {
360                Scope::new(v).map_err(|e| Error::custom(format!("Invalid scope: {:?}", e)))
361            }
362        }
363
364        deserializer.deserialize_str(ScopeVisitor)
365    }
366}
367
368/// Wrapper to get around the fact Rust `f64` doesn't implement `Ord` and there is no non-NaN
369/// float type
370#[derive(Debug, Copy, Clone, PartialOrd, PartialEq)]
371pub struct MatchPower(pub f64);
372
373impl Eq for MatchPower {}
374
375#[allow(clippy::derive_ord_xor_partial_ord)] // The code works, so let's keep using it
376impl Ord for MatchPower {
377    fn cmp(&self, other: &Self) -> Ordering {
378        self.partial_cmp(other).unwrap()
379    }
380}
381
382impl ScopeStack {
383    pub fn new() -> ScopeStack {
384        ScopeStack {
385            clear_stack: Vec::new(),
386            scopes: Vec::new()
387        }
388    }
389
390    /// Note: creating a ScopeStack with this doesn't contain information
391    /// on what to do when `clear_scopes` contexts end.
392    pub fn from_vec(v: Vec<Scope>) -> ScopeStack {
393        ScopeStack {
394            clear_stack: Vec::new(),
395            scopes: v
396        }
397    }
398
399    #[inline]
400    pub fn push(&mut self, s: Scope) {
401        self.scopes.push(s);
402    }
403
404    #[inline]
405    pub fn pop(&mut self) {
406        self.scopes.pop();
407    }
408
409    /// Modifies this stack according to the operation given
410    ///
411    /// Use this to create a stack from a `Vec` of changes given by the parser.
412    pub fn apply(&mut self, op: &ScopeStackOp) -> Result<(), ScopeError> {
413        self.apply_with_hook(op, |_,_|{})
414    }
415
416    /// Modifies this stack according to the operation given and calls the hook for each basic operation.
417    ///
418    /// Like [`apply`] but calls `hook` for every basic modification (as defined by
419    /// [`BasicScopeStackOp`]). Use this to do things only when the scope stack changes.
420    ///
421    /// [`apply`]: #method.apply
422    /// [`BasicScopeStackOp`]: enum.BasicScopeStackOp.html
423    #[inline]
424    pub fn apply_with_hook<F>(&mut self, op: &ScopeStackOp, mut hook: F) -> Result<(), ScopeError>
425        where F: FnMut(BasicScopeStackOp, &[Scope])
426    {
427        match *op {
428            ScopeStackOp::Push(scope) => {
429                self.scopes.push(scope);
430                hook(BasicScopeStackOp::Push(scope), self.as_slice());
431            }
432            ScopeStackOp::Pop(count) => {
433                for _ in 0..count {
434                    self.scopes.pop();
435                    hook(BasicScopeStackOp::Pop, self.as_slice());
436                }
437            }
438            ScopeStackOp::Clear(amount) => {
439                let cleared = match amount {
440                    ClearAmount::TopN(n) => {
441                        // don't try to clear more scopes than are on the stack
442                        let to_leave = self.scopes.len() - min(n, self.scopes.len());
443                        self.scopes.split_off(to_leave)
444                    }
445                    ClearAmount::All => {
446                        let mut cleared = Vec::new();
447                        mem::swap(&mut cleared, &mut self.scopes);
448                        cleared
449                    }
450                };
451                let clear_amount = cleared.len();
452                self.clear_stack.push(cleared);
453                for _ in 0..clear_amount {
454                    hook(BasicScopeStackOp::Pop, self.as_slice());
455                }
456            }
457            ScopeStackOp::Restore => {
458                match self.clear_stack.pop() {
459                    Some(ref mut to_push) => {
460                        for s in to_push {
461                            self.scopes.push(*s);
462                            hook(BasicScopeStackOp::Push(*s), self.as_slice());
463                        }
464                    }
465                    None => return Err(ScopeError::NoClearedScopesToRestore),
466                }
467            }
468            ScopeStackOp::Noop => (),
469        }
470
471        Ok(())
472    }
473
474    /// Prints out each scope in the stack separated by spaces
475    /// and then a newline. Top of the stack at the end.
476    pub fn debug_print(&self, repo: &ScopeRepository) {
477        for s in &self.scopes {
478            print!("{} ", repo.to_string(*s));
479        }
480        println!();
481    }
482
483    /// Returns the bottom `n` elements of the stack.
484    ///
485    /// Equivalent to `&scopes[0..n]` on a `Vec`
486    pub fn bottom_n(&self, n: usize) -> &[Scope] {
487        &self.scopes[0..n]
488    }
489
490    /// Return a slice of the scopes in this stack
491    #[inline]
492    pub fn as_slice(&self) -> &[Scope] {
493        &self.scopes[..]
494    }
495
496    /// Return the height/length of this stack
497    #[inline]
498    pub fn len(&self) -> usize {
499        self.scopes.len()
500    }
501
502    #[inline]
503    pub fn is_empty(&self) -> bool {
504        self.len() == 0
505    }
506
507    /// Checks if this stack as a selector matches the given stack, returning the match score if so
508    ///
509    /// Higher match scores indicate stronger matches. Scores are ordered according to the rules
510    /// found at [https://manual.macromates.com/en/scope_selectors](https://manual.macromates.com/en/scope_selectors)
511    ///
512    /// It accomplishes this ordering through some floating point math ensuring deeper and longer
513    /// matches matter. Unfortunately it is only guaranteed to return perfectly accurate results up
514    /// to stack depths of 17, but it should be reasonably good even afterwards. TextMate has the
515    /// exact same limitation, dunno about Sublime Text.
516    ///
517    /// # Examples
518    /// ```
519    /// use syntect::parsing::{ScopeStack, MatchPower};
520    /// use std::str::FromStr;
521    /// assert_eq!(ScopeStack::from_str("a.b c e.f").unwrap()
522    ///     .does_match(ScopeStack::from_str("a.b c.d e.f.g").unwrap().as_slice()),
523    ///     Some(MatchPower(0o212u64 as f64)));
524    /// assert_eq!(ScopeStack::from_str("a c.d.e").unwrap()
525    ///     .does_match(ScopeStack::from_str("a.b c.d e.f.g").unwrap().as_slice()),
526    ///     None);
527    /// ```
528    pub fn does_match(&self, stack: &[Scope]) -> Option<MatchPower> {
529        let mut sel_index: usize = 0;
530        let mut score: f64 = 0.0;
531        for (i, scope) in stack.iter().enumerate() {
532            let sel_scope = self.scopes[sel_index];
533            if sel_scope.is_prefix_of(*scope) {
534                let len = sel_scope.len();
535                // equivalent to score |= len << (ATOM_LEN_BITS*i) on a large unsigned
536                score += f64::from(len) * f64::from(ATOM_LEN_BITS * (i as u16)).exp2();
537                sel_index += 1;
538                if sel_index >= self.scopes.len() {
539                    return Some(MatchPower(score));
540                }
541            }
542        }
543        None
544    }
545}
546
547impl FromStr for ScopeStack {
548    type Err = ParseScopeError;
549
550    /// Parses a scope stack from a whitespace separated list of scopes.
551    fn from_str(s: &str) -> Result<ScopeStack, ParseScopeError> {
552        let mut scopes = Vec::new();
553        for name in s.split_whitespace() {
554            scopes.push(Scope::from_str(name)?)
555        }
556        Ok(ScopeStack::from_vec(scopes))
557    }
558}
559
560impl fmt::Display for ScopeStack {
561    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
562        for s in &self.scopes {
563            write!(f, "{} ", s)?;
564        }
565        Ok(())
566    }
567}
568
569#[cfg(test)]
570mod tests {
571    use super::*;
572
573    #[test]
574    fn misc() {
575        // use std::mem;
576        // use std::rc::{Rc};
577        // use scope::*;
578        // assert_eq!(8, mem::size_of::<Rc<Scope>>());
579        // assert_eq!(Scope::new("source.php"), Scope::new("source.php"));
580    }
581
582    #[test]
583    fn repo_works() {
584        let mut repo = ScopeRepository::new();
585        assert_eq!(repo.build("source.php").unwrap(),
586                   repo.build("source.php").unwrap());
587        assert_eq!(repo.build("source.php.wow.hi.bob.troll.clock.5").unwrap(),
588                   repo.build("source.php.wow.hi.bob.troll.clock.5").unwrap());
589        assert_eq!(repo.build("").unwrap(), repo.build("").unwrap());
590        let s1 = repo.build("").unwrap();
591        assert_eq!(repo.to_string(s1), "");
592        let s2 = repo.build("source.php.wow").unwrap();
593        assert_eq!(repo.to_string(s2), "source.php.wow");
594        assert!(repo.build("source.php").unwrap() != repo.build("source.perl").unwrap());
595        assert!(repo.build("source.php").unwrap() != repo.build("source.php.wagon").unwrap());
596        assert_eq!(repo.build("comment.line.").unwrap(),
597                   repo.build("comment.line").unwrap());
598    }
599
600    #[test]
601    fn global_repo_works() {
602        use std::str::FromStr;
603        assert_eq!(Scope::new("source.php").unwrap(),
604                   Scope::new("source.php").unwrap());
605        assert!(Scope::from_str("1.2.3.4.5.6.7.8").is_ok());
606        assert!(Scope::from_str("1.2.3.4.5.6.7.8.9").is_err());
607    }
608
609    #[test]
610    fn prefixes_work() {
611        assert!(Scope::new("1.2.3.4.5.6.7.8")
612            .unwrap()
613            .is_prefix_of(Scope::new("1.2.3.4.5.6.7.8").unwrap()));
614        assert!(Scope::new("1.2.3.4.5.6")
615            .unwrap()
616            .is_prefix_of(Scope::new("1.2.3.4.5.6.7.8").unwrap()));
617        assert!(Scope::new("1.2.3.4")
618            .unwrap()
619            .is_prefix_of(Scope::new("1.2.3.4.5.6.7.8").unwrap()));
620        assert!(!Scope::new("1.2.3.4.5.6.a")
621            .unwrap()
622            .is_prefix_of(Scope::new("1.2.3.4.5.6.7.8").unwrap()));
623        assert!(!Scope::new("1.2.a.4.5.6.7")
624            .unwrap()
625            .is_prefix_of(Scope::new("1.2.3.4.5.6.7.8").unwrap()));
626        assert!(!Scope::new("1.2.a.4.5.6.7")
627            .unwrap()
628            .is_prefix_of(Scope::new("1.2.3.4.5").unwrap()));
629        assert!(!Scope::new("1.2.a")
630            .unwrap()
631            .is_prefix_of(Scope::new("1.2.3.4.5.6.7.8").unwrap()));
632    }
633
634    #[test]
635    fn matching_works() {
636        use std::str::FromStr;
637        assert_eq!(ScopeStack::from_str("string")
638                       .unwrap()
639                       .does_match(ScopeStack::from_str("string.quoted").unwrap().as_slice()),
640                   Some(MatchPower(0o1u64 as f64)));
641        assert_eq!(ScopeStack::from_str("source")
642                       .unwrap()
643                       .does_match(ScopeStack::from_str("string.quoted").unwrap().as_slice()),
644                   None);
645        assert_eq!(ScopeStack::from_str("a.b e.f")
646                       .unwrap()
647                       .does_match(ScopeStack::from_str("a.b c.d e.f.g").unwrap().as_slice()),
648                   Some(MatchPower(0o202u64 as f64)));
649        assert_eq!(ScopeStack::from_str("c e.f")
650                       .unwrap()
651                       .does_match(ScopeStack::from_str("a.b c.d e.f.g").unwrap().as_slice()),
652                   Some(MatchPower(0o210u64 as f64)));
653        assert_eq!(ScopeStack::from_str("c.d e.f")
654                       .unwrap()
655                       .does_match(ScopeStack::from_str("a.b c.d e.f.g").unwrap().as_slice()),
656                   Some(MatchPower(0o220u64 as f64)));
657        assert_eq!(ScopeStack::from_str("a.b c e.f")
658                       .unwrap()
659                       .does_match(ScopeStack::from_str("a.b c.d e.f.g").unwrap().as_slice()),
660                   Some(MatchPower(0o212u64 as f64)));
661        assert_eq!(ScopeStack::from_str("a c.d")
662                       .unwrap()
663                       .does_match(ScopeStack::from_str("a.b c.d e.f.g").unwrap().as_slice()),
664                   Some(MatchPower(0o021u64 as f64)));
665        assert_eq!(ScopeStack::from_str("a c.d.e")
666                       .unwrap()
667                       .does_match(ScopeStack::from_str("a.b c.d e.f.g").unwrap().as_slice()),
668                   None);
669    }
670}
syntect/parsing/scope.rs

syntect/parsing/
scope.rs
