[Quick Open] Make the calculateScore function more clear for future debugging

Bug: 391533572
Change-Id: If3e3d4378c83a7e6d598058cbb50725e0bc8c7f0
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6189461
Auto-Submit: Nancy Li <[email protected]>
Commit-Queue: Nancy Li <[email protected]>
Reviewed-by: Kateryna Prokopenko <[email protected]>
Commit-Queue: Kateryna Prokopenko <[email protected]>

Author: Nancy Li

front_end/panels/sources/FilePathScoreFunction.ts

@@ -45,40 +45,60 @@ export class FilePathScoreFunction {
     this.fileNameIndex = 0;
   }
 
+  /**
+   * Calculates the score of a given data string against the query string.
+   *
+   * The score is calculated by comparing the characters of the query string to
+   * the characters of the data string. Characters that match are given a score
+   * of 10, while characters that don't match are given a score of 0. The score
+   * of a match is also influenced by the context of the match. For example,
+   * matching the beginning of the file name is worth more than matching a
+   * character in the middle of the file name.
+   *
+   * The score of a match is also influenced by the number of consecutive
+   * matches. The more consecutive matches there are, the higher the score.
+   *
+   * @param data The data string to score.
+   * @param matchIndexes An optional array to store the indexes of matching
+   * characters. If provided, it will be filled with the indexes of the matching
+   * characters in the data string.
+   * @returns The score of the data string.
+   */
   calculateScore(data: string, matchIndexes: number[]|null): number {
     if (!data || !this.query) {
       return 0;
     }
-    const n = this.query.length;
-    const m = data.length;
-    if (!this.score || this.score.length < n * m) {
-      this.score = new Int32Array(n * m * 2);
-      this.sequence = new Int32Array(n * m * 2);
+    const queryLength = this.query.length;
+    const dataLength = data.length;
+    if (!this.score || this.score.length < queryLength * dataLength) {
+      this.score = new Int32Array(queryLength * dataLength * 2);
+      this.sequence = new Int32Array(queryLength * dataLength * 2);
     }
     const score = this.score;
     const sequence = (this.sequence as Int32Array);
     this.dataUpperCase = data.toUpperCase();
     this.fileNameIndex = data.lastIndexOf('/');
-    for (let i = 0; i < n; ++i) {
-      for (let j = 0; j < m; ++j) {
-        const skipCharScore = j === 0 ? 0 : score[i * m + j - 1];
-        const prevCharScore = i === 0 || j === 0 ? 0 : score[(i - 1) * m + j - 1];
-        const consecutiveMatch = i === 0 || j === 0 ? 0 : sequence[(i - 1) * m + j - 1];
+    for (let i = 0; i < queryLength; ++i) {
+      for (let j = 0; j < dataLength; ++j) {
+        const scoreIndex = i * dataLength + j;
+        const skipCharScore = j === 0 ? 0 : score[scoreIndex - 1];
+        const prevCharScore = i === 0 || j === 0 ? 0 : score[(i - 1) * dataLength + j - 1];
+        const consecutiveMatch = i === 0 || j === 0 ? 0 : sequence[(i - 1) * dataLength + j - 1];
         const pickCharScore = this.match(this.query, data, i, j, consecutiveMatch);
         if (pickCharScore && prevCharScore + pickCharScore >= skipCharScore) {
-          sequence[i * m + j] = consecutiveMatch + 1;
-          score[i * m + j] = (prevCharScore + pickCharScore);
+          sequence[scoreIndex] = consecutiveMatch + 1;
+          score[scoreIndex] = (prevCharScore + pickCharScore);
         } else {
-          sequence[i * m + j] = 0;
-          score[i * m + j] = skipCharScore;
+          sequence[scoreIndex] = 0;
+          score[scoreIndex] = skipCharScore;
         }
       }
     }
     if (matchIndexes) {
-      this.restoreMatchIndexes(sequence, n, m, matchIndexes);
+      this.restoreMatchIndexes(sequence, queryLength, dataLength, matchIndexes);
     }
     const maxDataLength = 256;
-    return score[n * m - 1] * maxDataLength + (maxDataLength - data.length);
+    return score[queryLength * dataLength - 1] * maxDataLength + (maxDataLength - data.length);
   }
 
   private testWordStart(data: string, j: number): boolean {
@@ -91,10 +111,10 @@ export class FilePathScoreFunction {
         (data[j - 1] !== this.dataUpperCase[j - 1] && data[j] === this.dataUpperCase[j]);
   }
 
-  private restoreMatchIndexes(sequence: Int32Array, n: number, m: number, out: number[]): void {
-    let i = n - 1, j = m - 1;
+  private restoreMatchIndexes(sequence: Int32Array, queryLength: number, dataLength: number, out: number[]): void {
+    let i = queryLength - 1, j = dataLength - 1;
     while (i >= 0 && j >= 0) {
-      switch (sequence[i * m + j]) {
+      switch (sequence[i * dataLength + j]) {
         case 0:
           --j;
           break;