Merge branch 'master' into patternMatcher_fns

Author: Andy Hanson

src/harness/unittests/services/patternMatcher.ts

@@ -127,7 +127,6 @@ describe("PatternMatcher", () => {
 
             assert.equal(ts.PatternMatchKind.camelCase, match.kind);
             assert.equal(true, match.isCaseSensitive);
-            assertInRange(match.camelCaseWeight, 1, 1 << 30);
         });
 
         it("PreferCaseSensitiveCamelCaseMatchPartialPattern", () => {
@@ -237,30 +236,6 @@ describe("PatternMatcher", () => {
             assert.equal(false, match.isCaseSensitive);
         });
 
-        it("PreferCaseSensitiveRelativeWeights1", () => {
-            const match1 = getFirstMatch("FogBarBaz", "FB");
-            const match2 = getFirstMatch("FooFlobBaz", "FB");
-
-            // We should prefer something that starts at the beginning if possible
-            assertInRange(match1.camelCaseWeight, match2.camelCaseWeight + 1, 1 << 30);
-        });
-
-        it("PreferCaseSensitiveRelativeWeights2", () => {
-            const match1 = getFirstMatch("BazBarFooFooFoo", "FFF");
-            const match2 = getFirstMatch("BazFogBarFooFoo", "FFF");
-
-            // Contiguous things should also be preferred
-            assertInRange(match1.camelCaseWeight, match2.camelCaseWeight + 1, 1 << 30);
-        });
-
-        it("PreferCaseSensitiveRelativeWeights3", () => {
-            const match1 = getFirstMatch("FogBarFooFoo", "FFF");
-            const match2 = getFirstMatch("BarFooFooFoo", "FFF");
-
-            // The weight of being first should be greater than the weight of being contiguous
-            assertInRange(match1.camelCaseWeight, match2.camelCaseWeight + 1, 1 << 30);
-        });
-
         it("AllLowerPattern1", () => {
             const match = getFirstMatch("FogBarChangedEventArgs", "changedeventargs");
 
@@ -507,11 +482,6 @@ describe("PatternMatcher", () => {
         }
     }
 
-    function assertInRange(val: number, low: number, high: number) {
-        assert.isTrue(val >= low);
-        assert.isTrue(val <= high);
-    }
-
     function verifyBreakIntoCharacterSpans(original: string, ...parts: string[]): void {
         assertArrayEquals(parts, breakIntoCharacterSpans(original));
     }

src/services/navigateTo.ts

@@ -56,9 +56,7 @@ namespace ts.NavigateTo {
                 }
             }
 
-            const matchKind = bestMatchKind(containerMatches);
-            const isCaseSensitive = allMatchesAreCaseSensitive(containerMatches);
-            rawItems.push({ name, fileName, matchKind, isCaseSensitive, declaration });
+            rawItems.push({ name, fileName, matchKind: Math.min(...matches.map(m => m.kind)), isCaseSensitive: matches.every(m => m.isCaseSensitive), declaration });
         }
     }
 
@@ -75,19 +73,6 @@ namespace ts.NavigateTo {
         }
     }
 
-    function allMatchesAreCaseSensitive(matches: ReadonlyArray<PatternMatch>): boolean {
-        Debug.assert(matches.length > 0);
-
-        // This is a case sensitive match, only if all the submatches were case sensitive.
-        for (const match of matches) {
-            if (!match.isCaseSensitive) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
     function tryAddSingleDeclarationName(declaration: Declaration, containers: string[]): boolean {
         const name = getNameOfDeclaration(declaration);
         if (name && isPropertyNameLiteral(name)) {
@@ -125,16 +110,14 @@ namespace ts.NavigateTo {
         return false;
     }
 
-    function getContainers(declaration: Declaration): string[] {
+    function getContainers(declaration: Declaration): string[] | undefined {
         const containers: string[] = [];
 
         // First, if we started with a computed property name, then add all but the last
         // portion into the container array.
         const name = getNameOfDeclaration(declaration);
-        if (name.kind === SyntaxKind.ComputedPropertyName) {
-            if (!tryAddComputedPropertyName(name.expression, containers, /*includeLastPortion*/ false)) {
-                return undefined;
-            }
+        if (name.kind === SyntaxKind.ComputedPropertyName && !tryAddComputedPropertyName(name.expression, containers, /*includeLastPortion*/ false)) {
+            return undefined;
         }
 
         // Now, walk up our containers, adding all their names to the container array.
@@ -151,20 +134,6 @@ namespace ts.NavigateTo {
         return containers;
     }
 
-    function bestMatchKind(matches: ReadonlyArray<PatternMatch>): PatternMatchKind {
-        Debug.assert(matches.length > 0);
-        let bestMatchKind = PatternMatchKind.camelCase;
-
-        for (const match of matches) {
-            const kind = match.kind;
-            if (kind < bestMatchKind) {
-                bestMatchKind = kind;
-            }
-        }
-
-        return bestMatchKind;
-    }
-
     function compareNavigateToItems(i1: RawNavigateToItem, i2: RawNavigateToItem) {
         // TODO(cyrusn): get the gamut of comparisons that VS already uses here.
         return compareValues(i1.matchKind, i2.matchKind)

src/services/patternMatcher.ts

@@ -15,19 +15,10 @@ namespace ts {
         // better than substring matches which are better than CamelCase matches.
         kind: PatternMatchKind;
 
-        // If this was a camel case match, how strong the match is.  Higher number means
-        // it was a better match.
-        camelCaseWeight?: number;
-
         // If this was a match where all constituent parts of the candidate and search pattern
         // matched case sensitively or case insensitively.  Case sensitive matches of the kind
         // are better matches than insensitive matches.
         isCaseSensitive: boolean;
-
-        // Whether or not this match occurred with the punctuation from the search pattern stripped
-        // out or not.  Matches without the punctuation stripped are better than ones with punctuation
-        // stripped.
-        punctuationStripped: boolean;
     }
 
     // The pattern matcher maintains an internal cache of information as it is used.  Therefore,
@@ -99,12 +90,10 @@ namespace ts {
         characterSpans: TextSpan[];
     }
 
-    function createPatternMatch(kind: PatternMatchKind, punctuationStripped: boolean, isCaseSensitive: boolean, camelCaseWeight?: number): PatternMatch {
+    function createPatternMatch(kind: PatternMatchKind, isCaseSensitive: boolean): PatternMatch {
         return {
             kind,
-            punctuationStripped,
-            isCaseSensitive,
-            camelCaseWeight
+            isCaseSensitive
         };
     }
 
@@ -184,18 +173,18 @@ namespace ts {
         return spans;
     }
 
-    function matchTextChunk(candidate: string, chunk: TextChunk, punctuationStripped: boolean, stringToWordSpans: Map<TextSpan[]>): PatternMatch {
+    function matchTextChunk(candidate: string, chunk: TextChunk, stringToWordSpans: Map<TextSpan[]>): PatternMatch {
         const index = indexOfIgnoringCase(candidate, chunk.textLowerCase);
         if (index === 0) {
             if (chunk.text.length === candidate.length) {
                 // a) Check if the part matches the candidate entirely, in an case insensitive or
                 //    sensitive manner.  If it does, return that there was an exact match.
-                return createPatternMatch(PatternMatchKind.exact, punctuationStripped, /*isCaseSensitive:*/ candidate === chunk.text);
+                return createPatternMatch(PatternMatchKind.exact, /*isCaseSensitive:*/ candidate === chunk.text);
             }
             else {
                 // b) Check if the part is a prefix of the candidate, in a case insensitive or sensitive
                 //    manner.  If it does, return that there was a prefix match.
-                return createPatternMatch(PatternMatchKind.prefix, punctuationStripped, /*isCaseSensitive:*/ startsWith(candidate, chunk.text));
+                return createPatternMatch(PatternMatchKind.prefix, /*isCaseSensitive:*/ startsWith(candidate, chunk.text));
             }
         }
 
@@ -212,8 +201,7 @@ namespace ts {
                 const wordSpans = getWordSpans(candidate, stringToWordSpans);
                 for (const span of wordSpans) {
                     if (partStartsWith(candidate, span, chunk.text, /*ignoreCase:*/ true)) {
-                        return createPatternMatch(PatternMatchKind.substring, punctuationStripped,
-                            /*isCaseSensitive:*/ partStartsWith(candidate, span, chunk.text, /*ignoreCase:*/ false));
+                        return createPatternMatch(PatternMatchKind.substring, /*isCaseSensitive:*/ partStartsWith(candidate, span, chunk.text, /*ignoreCase:*/ false));
                     }
                 }
             }
@@ -223,22 +211,18 @@ namespace ts {
             //    candidate in a case *sensitive* manner. If so, return that there was a substring
             //    match.
             if (candidate.indexOf(chunk.text) > 0) {
-                return createPatternMatch(PatternMatchKind.substring, punctuationStripped, /*isCaseSensitive:*/ true);
+                return createPatternMatch(PatternMatchKind.substring, /*isCaseSensitive:*/ true);
             }
         }
 
         if (!isLowercase) {
             // e) If the part was not entirely lowercase, then attempt a camel cased match as well.
             if (chunk.characterSpans.length > 0) {
                 const candidateParts = getWordSpans(candidate, stringToWordSpans);
-                let camelCaseWeight = tryCamelCaseMatch(candidate, candidateParts, chunk, /*ignoreCase:*/ false);
-                if (camelCaseWeight !== undefined) {
-                    return createPatternMatch(PatternMatchKind.camelCase, punctuationStripped, /*isCaseSensitive:*/ true, /*camelCaseWeight:*/ camelCaseWeight);
-                }
-
-                camelCaseWeight = tryCamelCaseMatch(candidate, candidateParts, chunk, /*ignoreCase:*/ true);
-                if (camelCaseWeight !== undefined) {
-                    return createPatternMatch(PatternMatchKind.camelCase, punctuationStripped, /*isCaseSensitive:*/ false, /*camelCaseWeight:*/ camelCaseWeight);
+                const isCaseSensitive = tryCamelCaseMatch(candidate, candidateParts, chunk, /*ignoreCase:*/ false) ? true
+                        : tryCamelCaseMatch(candidate, candidateParts, chunk, /*ignoreCase:*/ true) ? false : undefined;
+                if (isCaseSensitive !== undefined) {
+                    return createPatternMatch(PatternMatchKind.camelCase, isCaseSensitive);
                 }
             }
         }
@@ -253,7 +237,7 @@ namespace ts {
             // (Pattern: fogbar, Candidate: quuxfogbarFogBar).
             if (chunk.text.length < candidate.length) {
                 if (index > 0 && isUpperCaseLetter(candidate.charCodeAt(index))) {
-                    return createPatternMatch(PatternMatchKind.substring, punctuationStripped, /*isCaseSensitive:*/ false);
+                    return createPatternMatch(PatternMatchKind.substring, /*isCaseSensitive:*/ false);
                 }
             }
         }
@@ -281,7 +265,7 @@ namespace ts {
         // Note: if the segment contains a space or an asterisk then we must assume that it's a
         // multi-word segment.
         if (!containsSpaceOrAsterisk(segment.totalTextChunk.text)) {
-            const match = matchTextChunk(candidate, segment.totalTextChunk, /*punctuationStripped:*/ false, stringToWordSpans);
+            const match = matchTextChunk(candidate, segment.totalTextChunk, stringToWordSpans);
             if (match) {
                 return [match];
             }
@@ -329,7 +313,7 @@ namespace ts {
 
         for (const subWordTextChunk of subWordTextChunks) {
             // Try to match the candidate with this word
-            const result = matchTextChunk(candidate, subWordTextChunk, /*punctuationStripped:*/ true, stringToWordSpans);
+            const result = matchTextChunk(candidate, subWordTextChunk, stringToWordSpans);
             if (!result) {
                 return undefined;
             }
@@ -372,7 +356,7 @@ namespace ts {
         return true;
     }
 
-    function tryCamelCaseMatch(candidate: string, candidateParts: TextSpan[], chunk: TextChunk, ignoreCase: boolean): number {
+    function tryCamelCaseMatch(candidate: string, candidateParts: TextSpan[], chunk: TextChunk, ignoreCase: boolean): boolean {
         const chunkCharacterSpans = chunk.characterSpans;
 
         // Note: we may have more pattern parts than candidate parts.  This is because multiple
@@ -388,24 +372,11 @@ namespace ts {
         while (true) {
             // Let's consider our termination cases
             if (currentChunkSpan === chunkCharacterSpans.length) {
-                // We did match! We shall assign a weight to this
-                let weight = 0;
-
-                // Was this contiguous?
-                if (contiguous) {
-                    weight += 1;
-                }
-
-                // Did we start at the beginning of the candidate?
-                if (firstMatch === 0) {
-                    weight += 2;
-                }
-
-                return weight;
+                return true;
             }
             else if (currentCandidate === candidateParts.length) {
                 // No match, since we still have more of the pattern to hit
-                return undefined;
+                return false;
             }
 
             let candidatePart = candidateParts[currentCandidate];