[analyzer] Replace pathContext.relative inside LocatedGlob.matches

Comparing a before and an after aot-compiled analysis server,
running each 25 times, via `pkg/front_end/tool/benchmarker.dart`:

```
out/ReleaseX64/dart pkg/front_end/tool/benchmarker.dart \
  --iterations=25 \
  --snapshot=pkg/analysis_server/bin/server.aot.1 \
  --snapshot=pkg/analysis_server/bin/server.aot.2 \
  --arguments="--disable-file-byte-store" \
  --arguments="--train-using" \
  --arguments="pkg/front_end/lib/"
```

(where `server.aot.1` is an aot-compile without this CL and
`server.aot.2` is an aot-compile with this CL) gets this result:

```
msec task-clock:u: -5.2977% +/- 0.4313% (-466.26 +/- 37.96) (8801.11 -> 8334.86)
page-faults:u: -2.5748% +/- 0.1648% (-4094.76 +/- 262.07) (159032.16 -> 154937.40)
cycles:u: -5.5212% +/- 0.4440% (-2034156211.44 +/- 163567376.21) (36842412971.36 -> 34808256759.92)
instructions:u: -8.2456% +/- 0.0556% (-4125031082.64 +/- 27819990.07) (50026884750.04 -> 45901853667.40)
branch-misses:u: -4.2637% +/- 2.0984% (-5839704.08 +/- 2873998.26) (136961902.80 -> 131122198.72)
seconds time elapsed: -5.2895% +/- 0.4311% (-0.47 +/- 0.04) (8.82 -> 8.35)
seconds user: -5.5473% +/- 0.5002% (-0.47 +/- 0.04) (8.46 -> 7.99)
Scavenge(   new space) goes from 152 to 134
MarkSweep(   promotion) goes from 15 to 14
Notice combined GC time goes from 2804 ms to 2707 ms (notice only 1 run each).
```
Change-Id: Ib5070b3c037b30f96bb91b3536d85b85ebe0c30c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/427442
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Jens Johansen <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: jensjoha

pkg/analyzer/api.txt

@@ -4538,6 +4538,7 @@ package:analyzer/file_system/file_system.dart:
     ready (getter: Future<void>)
   FolderExtension (extension on Folder):
     withAncestors (getter: Iterable<Folder>)
+    relativeIfContains (method: String? Function(String))
 package:analyzer/file_system/memory_file_system.dart:
   MemoryResourceProvider (class extends Object implements ResourceProvider):
     new (constructor: MemoryResourceProvider Function({Context? context, Duration? delayWatcherInitialization}))

pkg/analyzer/lib/file_system/file_system.dart

@@ -279,4 +279,31 @@ extension FolderExtension on Folder {
       current = current.parent;
     }
   }
+
+  /// Return a relative path if the [path] references a resource in this folder,
+  /// or `null` if it doesn't.
+  ///
+  /// The [path] must be absolute and normalized.
+  String? relativeIfContains(String path) {
+    // Given that paths are absolute and normalized the below is equivalent,
+    // but much faster, than something like
+    // ```
+    // if (parent.contains(path)) {
+    //  return provider.pathContext.relative(path, from: this.path);
+    // }
+    // return null;
+    // ```
+    String parent = this.path;
+    if (path.length <= parent.length) return null;
+    int separator = path.codeUnitAt(parent.length);
+    var style = provider.pathContext.style;
+    if (!style.isSeparator(separator)) return null;
+    for (var i = 0; i < parent.length; i++) {
+      if (parent.codeUnitAt(i) != path.codeUnitAt(i) &&
+          !style.codeUnitsEqual(parent.codeUnitAt(i), path.codeUnitAt(i))) {
+        return null;
+      }
+    }
+    return path.substring(parent.length + 1);
+  }
 }

pkg/analyzer/lib/src/dart/analysis/context_root.dart

@@ -183,11 +183,8 @@ class LocatedGlob {
   LocatedGlob(this.parent, this.glob);
 
   bool matches(String path) {
-    if (parent.contains(path)) {
-      var pathContext = parent.provider.pathContext;
-      var relativePath = pathContext.relative(path, from: parent.path);
-      return glob.matches(relativePath);
-    }
-    return false;
+    var relativePath = parent.relativeIfContains(path);
+    if (relativePath == null) return false;
+    return glob.matches(relativePath);
   }
 }

pkg/analyzer/test/file_system/file_system_test_support.dart

@@ -989,6 +989,67 @@ mixin FolderTestMixin implements FileSystemTestSupport {
     }
   }
 
+  test_relative_if_contains_immediateChild() {
+    Folder folder = getFolder(exists: false);
+    expect(
+      folder.relativeIfContains(join(defaultFolderPath, 'aaa.txt')),
+      'aaa.txt',
+    );
+  }
+
+  test_relative_if_contains_nestedChild() {
+    Folder folder = getFolder(exists: false);
+    expect(
+      folder.relativeIfContains(join(defaultFolderPath, 'aaa', 'bbb.txt')),
+      join('aaa', 'bbb.txt'),
+    );
+  }
+
+  test_relative_if_contains_os_specificic() {
+    Folder folder = getFolder(exists: false);
+    // On non-Windows path casing does matter.
+    String? expectOnCaseDifferenceImmediateChild;
+    String? expectOnCaseDifferenceNestedChild;
+    if (provider.pathContext.style.name == path.Style.windows.name) {
+      // On Windows path casing doesn't matter.
+      expectOnCaseDifferenceImmediateChild = 'aaa.txt';
+      expectOnCaseDifferenceNestedChild = join('aaa', 'bbb.txt');
+    }
+
+    var caseChangedFolder = defaultFolderPath.toUpperCase();
+
+    // Immediate child.
+    expect(
+      folder.relativeIfContains(join(caseChangedFolder, 'aaa.txt')),
+      expectOnCaseDifferenceImmediateChild,
+    );
+
+    // Nested child.
+    expect(
+      folder.relativeIfContains(join(caseChangedFolder, 'aaa', 'bbb.txt')),
+      expectOnCaseDifferenceNestedChild,
+    );
+
+    // Self (on Windows).
+    expect(folder.relativeIfContains(caseChangedFolder), isNull);
+
+    // Unrelated.
+    expect(
+      folder.relativeIfContains(join(tempPath.toUpperCase(), 'baz.txt')),
+      isNull,
+    );
+  }
+
+  test_relative_if_contains_self() {
+    Folder folder = getFolder(exists: false);
+    expect(folder.relativeIfContains(defaultFolderPath), isNull);
+  }
+
+  test_relative_if_contains_unrelated() {
+    Folder folder = getFolder(exists: false);
+    expect(folder.relativeIfContains(join(tempPath, 'baz.txt')), isNull);
+  }
+
   test_resolveSymbolicLinksSync_links_existing() {
     if (!hasSymbolicLinkSupport) return;