diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 7c68306211a..3ca4abc69da 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -20,6 +20,9 @@ namespace ts {
 
     const createObject = Object.create;
 
+    // More efficient to create a collator once and use its `compare` than to call `a.localeCompare(b)` many times.
+    export const collator: { compare(a: string, b: string): number } = typeof Intl === "object" && typeof Intl.Collator === "function" ? new Intl.Collator() : undefined;
+
     export function createMap<T>(template?: MapLike<T>): Map<T> {
         const map: Map<T> = createObject(null); // tslint:disable-line:no-null-keyword
 
@@ -1016,7 +1019,8 @@ namespace ts {
         if (a === undefined) return Comparison.LessThan;
         if (b === undefined) return Comparison.GreaterThan;
         if (ignoreCase) {
-            if (String.prototype.localeCompare) {
+            if (collator && String.prototype.localeCompare) {
+                // accent means a ≠ b, a ≠ á, a = A
                 const result = a.localeCompare(b, /*locales*/ undefined, { usage: "sort", sensitivity: "accent" });
                 return result < 0 ? Comparison.LessThan : result > 0 ? Comparison.GreaterThan : Comparison.EqualTo;
             }
diff --git a/src/harness/harness.ts b/src/harness/harness.ts
index 7c82aeece78..9d27257c80f 100644
--- a/src/harness/harness.ts
+++ b/src/harness/harness.ts
@@ -1634,7 +1634,7 @@ namespace Harness {
 
         export function collateOutputs(outputFiles: Harness.Compiler.GeneratedFile[]): string {
             // Collect, test, and sort the fileNames
-            outputFiles.sort((a, b) => cleanName(a.fileName).localeCompare(cleanName(b.fileName)));
+            outputFiles.sort((a, b) => ts.compareStrings(cleanName(a.fileName), cleanName(b.fileName)));
 
             // Emit them
             let result = "";
diff --git a/src/server/session.ts b/src/server/session.ts
index bd31277716f..539142eff18 100644
--- a/src/server/session.ts
+++ b/src/server/session.ts
@@ -967,7 +967,7 @@ namespace ts.server {
                         result.push({ name, kind, kindModifiers, sortText, replacementSpan: convertedSpan });
                     }
                     return result;
-                }, []).sort((a, b) => a.name.localeCompare(b.name));
+                }, []).sort((a, b) => ts.compareStrings(a.name, b.name));
             }
             else {
                 return completions;
diff --git a/src/services/navigateTo.ts b/src/services/navigateTo.ts
index 44aa25f5005..82f4dd49f2b 100644
--- a/src/services/navigateTo.ts
+++ b/src/services/navigateTo.ts
@@ -6,9 +6,6 @@ namespace ts.NavigateTo {
         const patternMatcher = createPatternMatcher(searchValue);
         let rawItems: RawNavigateToItem[] = [];
 
-        // This means "compare in a case insensitive manner."
-        const baseSensitivity: Intl.CollatorOptions = { sensitivity: "base" };
-
         // Search the declarations in all files and output matched NavigateToItem into array of NavigateToItem[]
         forEach(sourceFiles, sourceFile => {
             cancellationToken.throwIfCancellationRequested();
@@ -188,8 +185,8 @@ namespace ts.NavigateTo {
             // We first sort case insensitively.  So "Aaa" will come before "bar".
             // Then we sort case sensitively, so "aaa" will come before "Aaa".
             return i1.matchKind - i2.matchKind ||
-                i1.name.localeCompare(i2.name, undefined, baseSensitivity) ||
-                i1.name.localeCompare(i2.name);
+                ts.compareStringsCaseInsensitive(i1.name, i2.name) ||
+                ts.compareStrings(i1.name, i2.name);
         }
 
         function createNavigateToItem(rawItem: RawNavigateToItem): NavigateToItem {
diff --git a/src/services/navigationBar.ts b/src/services/navigationBar.ts
index 18881ae7660..7b4fb8cdba6 100644
--- a/src/services/navigationBar.ts
+++ b/src/services/navigationBar.ts
@@ -330,10 +330,8 @@ namespace ts.NavigationBar {
         }
     }
 
-    // More efficient to create a collator once and use its `compare` than to call `a.localeCompare(b)` many times.
-    const collator: { compare(a: string, b: string): number } = typeof Intl === "object" && typeof Intl.Collator === "function" ? new Intl.Collator() : undefined;
     // Intl is missing in Safari, and node 0.10 treats "a" as greater than "B".
-    const localeCompareIsCorrect = collator && collator.compare("a", "B") < 0;
+    const localeCompareIsCorrect = ts.collator && ts.collator.compare("a", "B") < 0;
     const localeCompareFix: (a: string, b: string) => number = localeCompareIsCorrect ? collator.compare : function(a, b) {
         // This isn't perfect, but it passes all of our tests.
         for (let i = 0; i < Math.min(a.length, b.length); i++) {
@@ -344,7 +342,7 @@ namespace ts.NavigationBar {
             if (chA === "'" && chB === "\"") {
                 return -1;
             }
-            const cmp = chA.toLocaleLowerCase().localeCompare(chB.toLocaleLowerCase());
+            const cmp = ts.compareStrings(chA.toLocaleLowerCase(), chB.toLocaleLowerCase());
             if (cmp !== 0) {
                 return cmp;
             }