Distinguish pop:N+push:/branch:/embed: from pop:N+set: at MatchOperation IR

.gitmodules

@@ -1,6 +1,7 @@
 [submodule "testdata/Packages"]
 	path = testdata/Packages
 	url = https://github.com/sublimehq/Packages
+	branch = v4202
 [submodule "testdata/InspiredGitHub.tmtheme"]
 	path = testdata/InspiredGitHub.tmtheme
 	url = https://github.com/sethlopezme/InspiredGitHub.tmtheme.git

src/parsing/metadata.rs

@@ -500,7 +500,9 @@ mod tests {
         let r = RawMetadataEntry::load(comments_file);
         assert!(r.is_ok());
 
-        let indent_file: &str = "testdata/Packages/Go/Indentation Rules.tmPreferences";
+        // v4202 still has the upstream "Indention" typo; renamed to
+        // "Indentation" by `1c86d7f9` post-v4202 (#4519).
+        let indent_file: &str = "testdata/Packages/Go/Indention Rules.tmPreferences";
         assert!(Path::new(indent_file).exists());
 
         let r = RawMetadataEntry::load(indent_file).unwrap();

src/parsing/regex.rs

@@ -345,4 +345,27 @@ mod tests {
         let back_to_str = serde_json::to_string(&pattern).unwrap();
         assert_eq!(back_to_str, "\"just a string\"");
     }
+
+    // The parser uses `end < text.len()` to clip a search at an embed-escape
+    // boundary. Negative lookaheads inside the embedded context's rules must
+    // treat the boundary as effective end-of-input — otherwise patterns like
+    // `done(?!cmd_char)` fail when `done` is immediately followed by the
+    // closing escape glyph (e.g. `` `for...done` `` in shell).
+    #[test]
+    fn search_clips_lookahead_at_end() {
+        let regex = Regex::new(String::from(r"done(?!X)"));
+        let mut region = Region::new();
+        let matched = regex.search("doneX", 0, 4, Some(&mut region), true);
+        assert!(matched, "lookahead must not see byte at index 4");
+        assert_eq!(region.pos(0), Some((0, 4)));
+    }
+
+    // Sanity check: when not clipped, the same lookahead correctly fails.
+    #[test]
+    fn search_lookahead_fails_when_unclipped() {
+        let regex = Regex::new(String::from(r"done(?!X)"));
+        let mut region = Region::new();
+        let matched = regex.search("doneX", 0, 5, Some(&mut region), true);
+        assert!(!matched, "lookahead must see the X when end == text.len()");
+    }
 }

src/parsing/scope.rs

@@ -182,9 +182,19 @@ impl ScopeRepository {
         if s.is_empty() {
             return Ok(Scope { a: 0, b: 0 });
         }
+        // Filter empty atoms so consecutive dots collapse — `variable.other..haskell`
+        // matches the same scope as `variable.other.haskell`. ST's selector engine
+        // treats them as equivalent (both score 48 against
+        // `source.haskell variable.other.haskell` via `sublime.score_selector`);
+        // syntect's previous implementation packed `""` as its own atom index,
+        // producing a 4-atom scope that didn't prefix-match the 3-atom target.
+        // Symmetric: applies to scope construction (`scope: foo..bar` typo) and
+        // to selector parsing (`syntax_test_haskell.hs:2348` line `:: a -> Bool`
+        // has `--         ^ variable.other..haskell` and ST passes it).
         let parts: Vec<usize> = s
             .trim_end_matches('.')
             .split('.')
+            .filter(|a| !a.is_empty())
             .map(|a| self.atom_to_index(a))
             .collect();
         // The internal representation supports at most 8 atoms (packed into
@@ -631,6 +641,20 @@ mod tests {
             repo.build("comment.line.").unwrap(),
             repo.build("comment.line").unwrap()
         );
+        // Empty atoms (consecutive dots) collapse, mirroring ST's selector
+        // engine where `score_selector('variable.other..haskell',
+        // 'source.haskell variable.other.haskell')` returns 48 — the same as
+        // for the single-dot form. Without the collapse, syntect packed `""`
+        // as its own atom, producing a 4-atom scope that didn't prefix-match
+        // the 3-atom target. Surfaced via `syntax_test_haskell.hs:2348` line
+        // `:: a -> Bool` whose `--         ^ variable.other..haskell`
+        // assertion ST passes against the same scope syntect produces.
+        assert_eq!(
+            repo.build("variable.other..haskell").unwrap(),
+            repo.build("variable.other.haskell").unwrap()
+        );
+        assert_eq!(repo.build("a..b").unwrap(), repo.build("a.b").unwrap());
+        assert_eq!(repo.build("a...b").unwrap(), repo.build("a.b").unwrap());
     }
 
     #[test]
@@ -725,5 +749,24 @@ mod tests {
                 .does_match(ScopeStack::from_str("a.b c.d e.f.g").unwrap().as_slice()),
             None
         );
+        // Selector with consecutive dots collapses to the equivalent
+        // single-dot form before matching: ST's `score_selector` returns the
+        // same MatchPower for both, and so should syntect.
+        assert_eq!(
+            ScopeStack::from_str("variable.other..haskell")
+                .unwrap()
+                .does_match(
+                    ScopeStack::from_str("source.haskell variable.other.haskell")
+                        .unwrap()
+                        .as_slice()
+                ),
+            ScopeStack::from_str("variable.other.haskell")
+                .unwrap()
+                .does_match(
+                    ScopeStack::from_str("source.haskell variable.other.haskell")
+                        .unwrap()
+                        .as_slice()
+                )
+        );
     }
 }

src/parsing/syntax_definition.rs

@@ -198,9 +198,19 @@ pub enum ContextReference {
 
 #[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
 pub enum MatchOperation {
-    Push(Vec<ContextReference>),
+    /// Pushes `ctx_refs`, optionally popping `pop_count` contexts first.
+    /// A plain `push:` is `pop_count == 0`; `pop: N + push:` is
+    /// `pop_count == N`. Per ST, `pop:N + push:` is **lookahead**: the
+    /// trigger token does not inherit the popped frames' meta_scope.
+    Push {
+        ctx_refs: Vec<ContextReference>,
+        #[serde(default)]
+        pop_count: usize,
+    },
     /// Pops `pop_count` contexts off the stack, then pushes `ctx_refs`.
     /// A plain `set:` is `pop_count == 1`; `pop: N + set:` is `pop_count == N`.
+    /// Per ST, `pop:N + set:` is **stacking**: the trigger token receives
+    /// both the popped frames' meta_scope and the pushed meta_scope.
     Set {
         ctx_refs: Vec<ContextReference>,
         #[serde(default = "one")]
@@ -274,17 +284,20 @@ impl<'a> Iterator for MatchIter<'a> {
                             _ => return self.next(),
                         };
                         let ctx_ptr = self.syntax_set.get_context(context_id).unwrap();
-                        // Also include the external syntax's prototype if the context allows it
+                        // Push target first, then external prototype on top so
+                        // its patterns are iterated first: `MatchIter::next`
+                        // reads the stack top, and ST's `apply_prototype` runs
+                        // the prototype ahead of the included context — mirror
+                        // of `ParseState::find_best_match`'s prototype chaining.
+                        self.ctx_stack.push(ctx_ptr);
+                        self.index_stack.push(0);
                         if ctx_ptr.meta_include_prototype.unwrap_or(true) {
                             if let Some(ref proto_id) = ctx_ptr.prototype {
                                 let proto_ctx = self.syntax_set.get_context(proto_id).unwrap();
-                                // Push prototype first (it will be iterated first)
                                 self.ctx_stack.push(proto_ctx);
                                 self.index_stack.push(0);
                             }
                         }
-                        self.ctx_stack.push(ctx_ptr);
-                        self.index_stack.push(0);
                     }
                 }
             } else {