feat: add child combinator ">" (and fix a specificity bug)

[aleclarson]

Closes #123

• Feature: Add support for the child combinator (the > operator). This allows for styling a parent-child relationship specifically.

  vscode-textmate/src/theme.ts

  Lines 173 to 180 in d63ed16

  	// Check for a child combinator (a parent-child relationship)
  	if (scopePattern === '>') {
  	if (index === parentScopes.length - 1) {
  	return false;
  	}
  	scopePattern = parentScopes[++index];
  	scopeMustMatch = true;
  	}

  vscode-textmate/src/theme.ts

  Lines 526 to 532 in d63ed16

  	// Child combinators don't affect specificity.
  	if (a.parentScopes[aParentIndex] === '>') {
  	aParentIndex++;
  	}
  	if (b.parentScopes[bParentIndex] === '>') {
  	bParentIndex++;
  	}

• Bug: If the number of scope names in both rules‘ scope paths are not equal, the parent scope names won‘t be compared at all. Instead, the rule with the longest scope path is preferred. This goes against the TextMate manual (https://macromates.com/manual/en/scope_selectors). In particular, the following line in “Ranking Matches”:

  Rules 1 and 2 applied again to the scope selector when removing the deepest element (in the case of a tie)

  vscode-textmate/src/theme.ts

  Lines 506 to 515 in 09effd8

  	if (aParentScopesLen === bParentScopesLen) {
  	for (let i = 0; i < aParentScopesLen; i++) {
  	const aLen = aParentScopes![i].length;
  	const bLen = bParentScopes![i].length;
  	if (aLen !== bLen) {
  	return bLen - aLen;
  	}
  	}
  	}
  	return bParentScopesLen - aParentScopesLen;

  How did I fix it?
  Do a depth-first, scope-by-scope comparison of the parent scopes, even if one of the rules has a longer scope path.

  vscode-textmate/src/theme.ts

  Lines 539 to 553 in 7c14889

  	// This is a scope-by-scope comparison, so we need to stop once a rule runs
  	// out of parent scopes.
  	if (aParentIndex >= a.parentScopes.length || bParentIndex >= b.parentScopes.length) {
  	break;
  	}
  	// When sorting by scope name specificity, it's safe to treat a longer parent
  	// scope as more specific. If both rules' parent scopes match a given scope
  	// path, the longer parent scope will always be more specific.
  	const parentScopeLengthDiff =
  	b.parentScopes[bParentIndex].length - a.parentScopes[aParentIndex].length;
  	if (parentScopeLengthDiff !== 0) {
  	return parentScopeLengthDiff;
  	}

Tests

• Child combinators
  

  vscode-textmate/src/tests/themes.test.ts

  Line 609 in 7c14889

  test('Theme resolving a rule with child combinator', () => {

• Bug
  

  vscode-textmate/src/tests/themes.test.ts

  Line 635 in 7c14889

  test('Theme resolving should give deeper scopes higher specificity (#233)', () => {

[aleclarson]

@hediet Excuse me if it's rude to tag, but I saw you're the only person to touch src/theme.ts in the last 2 years, so I would very much appreciate a code review if you can find the time! ❤️

Test cases incoming...

[aleclarson]

Okay tests have been added! Both fail on main branch.

[alexdima]

This looks very good! Thank you! ❤️