support backrefs in included contexts

src/parsing/parser.rs

@@ -1691,6 +1691,27 @@ contexts:
         expect_scope_stacks("\u{1F600}x", &["<source.test>, <test.good>"], syntax);
     }
 
+    #[test]
+    fn can_include_backrefs() {
+        let syntax = SyntaxDefinition::load_from_str(r#"
+                name: Backref Include Test
+                scope: source.backrefinc
+                contexts:
+                  main:
+                    - match: (a)
+                      scope: a
+                      push: context1
+                  context1:
+                    - include: context2
+                  context2:
+                    - match: \1
+                      scope: b
+                      pop: true
+                "#, true, None).unwrap();
+
+        expect_scope_stacks_with_syntax(&"aa", &["<a>", "<b>"], syntax);
+    }
+
     fn expect_scope_stacks(line_without_newline: &str, expect: &[&str], syntax: &str) {
         println!("Parsing with newlines");
         let line_with_newline = format!("{}\n", line_without_newline);

src/parsing/syntax_set.rs

@@ -495,6 +495,32 @@ impl SyntaxSetBuilder {
                 }
                 Self::link_context(&mut context, syntax, &syntaxes);
             }
+
+            for context_id in syntax.contexts.values() {
+                let index = context_id.index();
+                let context = &all_contexts[index];
+                if !context.uses_backrefs {
+                    let mut uses_backrefs = false;
+                    for pattern in &context.patterns {
+                        match *pattern {
+                            Pattern::Include(ref context_ref) => {
+                                match context_ref {
+                                    ContextReference::Direct(ref id) => {
+                                        if (&all_contexts[id.index()]).uses_backrefs {
+                                            uses_backrefs = true;
+                                            break;
+                                        }
+                                    }, _ => {},
+                                }
+                            }, _ => {},
+                        }
+                    }
+                    if uses_backrefs {
+                        let mut context = &mut all_contexts[index];
+                        context.uses_backrefs = true;
+                    }
+                }
+            }
         }
 
         #[cfg(feature = "metadata")]