microsoft · Aug 18, 2017 · Aug 18, 2017
diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts
@@ -686,7 +686,7 @@ namespace Harness.LanguageService {
            this.host.log(message);
        }

-        err(message: string): void {
+        msg(message: string): void {
            this.host.log(message);
        }

@@ -702,7 +702,8 @@ namespace Harness.LanguageService {
            return false;
        }

-        group() { throw ts.notImplemented(); }
+        startGroup() { throw ts.notImplemented(); }
+        endGroup() { throw ts.notImplemented(); }

        perftrc(message: string): void {
            return this.host.log(message);

diff --git a/src/harness/unittests/tsserverProjectSystem.ts b/src/harness/unittests/tsserverProjectSystem.ts
@@ -39,8 +39,9 @@ namespace ts.projectSystem {
        loggingEnabled: () => false,
        perftrc: noop,
        info: noop,
-        err: noop,
-        group: noop,
+        msg: noop,
+        startGroup: noop,
+        endGroup: noop,
        getLogFileName: (): string => undefined
    };


diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
@@ -958,28 +958,28 @@ namespace ts.server {
                return;
            }

-            this.logger.group(info => {
-                let counter = 0;
-                counter = printProjects(this.externalProjects, info, counter);
-                counter = printProjects(this.configuredProjects, info, counter);
-                printProjects(this.inferredProjects, info, counter);
-
-                info("Open files: ");
-                for (const rootFile of this.openFiles) {
-                    info(`\t${rootFile.fileName}`);
-                }
-            });
-
-            function printProjects(projects: Project[], info: (msg: string) => void, counter: number): number {
+            this.logger.startGroup();
+            let counter = 0;
+            const printProjects = (projects: Project[], counter: number): number => {
                for (const project of projects) {
                    project.updateGraph();
-                    info(`Project '${project.getProjectName()}' (${ProjectKind[project.projectKind]}) ${counter}`);
-                    info(project.filesToString());
-                    info("-----------------------------------------------");
+                    this.logger.info(`Project '${project.getProjectName()}' (${ProjectKind[project.projectKind]}) ${counter}`);
+                    this.logger.info(project.filesToString());
+                    this.logger.info("-----------------------------------------------");
                    counter++;
                }
                return counter;
+            };
+            counter = printProjects(this.externalProjects, counter);
+            counter = printProjects(this.configuredProjects, counter);
+            printProjects(this.inferredProjects, counter);
+
+            this.logger.info("Open files: ");
+            for (const rootFile of this.openFiles) {
+                this.logger.info(`\t${rootFile.fileName}`);
            }
+
+            this.logger.endGroup();
        }

        private findConfiguredProjectByProjectName(configFileName: NormalizedPath) {

diff --git a/src/server/server.ts b/src/server/server.ts
@@ -140,6 +140,8 @@ namespace ts.server {
    class Logger implements server.Logger {
        private fd = -1;
        private seq = 0;
+        private inGroup = false;
+        private firstInGroup = true;

        constructor(private readonly logFilename: string,
            private readonly traceToConsole: boolean,
@@ -169,24 +171,24 @@ namespace ts.server {
        }

        perftrc(s: string) {
-            this.msg(s, "Perf");
+            this.msg(s, Msg.Perf);
        }

        info(s: string) {
-            this.msg(s, "Info");
+            this.msg(s, Msg.Info);
        }

        err(s: string) {
-            this.msg(s, "Err");
+            this.msg(s, Msg.Err);
        }

-        group(logGroupEntries: (log: (msg: string) => void) => void) {
-            let firstInGroup = false;
-            logGroupEntries(s => {
-                this.msg(s, "Info", /*inGroup*/ true, firstInGroup);
-                firstInGroup = false;
-            });
-            this.seq++;
+        startGroup() {
+            this.inGroup = true;
+            this.firstInGroup = true;
+        }
+
+        endGroup() {
+            this.inGroup = false;
        }

        loggingEnabled() {
@@ -197,16 +199,16 @@ namespace ts.server {
            return this.loggingEnabled() && this.level >= level;
        }

-        private msg(s: string, type: string, inGroup = false, firstInGroup = false) {
+        msg(s: string, type: Msg.Types = Msg.Err) {
            if (!this.canWrite) return;

            s = `[${nowString()}] ${s}\n`;
-            if (!inGroup || firstInGroup) {
+            if (!this.inGroup || this.firstInGroup) {
                const prefix = Logger.padStringRight(type + " " + this.seq.toString(), "          ");
                s = prefix + s;
            }
            this.write(s);
-            if (!inGroup) {
+            if (!this.inGroup) {
                this.seq++;
            }
        }

diff --git a/src/server/session.ts b/src/server/session.ts
@@ -368,7 +368,7 @@ namespace ts.server {
                    msg += "\n" + (<StackTraceError>err).stack;
                }
            }
-            this.logger.err(msg);
+            this.logger.msg(msg, Msg.Err);
        }

        public send(msg: protocol.Message) {
@@ -1947,7 +1947,7 @@ namespace ts.server {
                return this.executeWithRequestId(request.seq, () => handler(request));
            }
            else {
-                this.logger.err(`Unrecognized JSON command: ${JSON.stringify(request)}`);
+                this.logger.msg(`Unrecognized JSON command: ${JSON.stringify(request)}`, Msg.Err);
                this.output(undefined, CommandNames.Unknown, request.seq, `Unrecognized JSON command: ${request.command}`);
                return { responseRequired: false };
            }

diff --git a/src/server/utilities.ts b/src/server/utilities.ts
@@ -17,11 +17,22 @@ namespace ts.server {
        loggingEnabled(): boolean;
        perftrc(s: string): void;
        info(s: string): void;
-        err(s: string): void;
-        group(logGroupEntries: (log: (msg: string) => void) => void): void;
+        startGroup(): void;
+        endGroup(): void;
+        msg(s: string, type?: Msg.Types): void;
        getLogFileName(): string;
    }

+    export namespace Msg {
+        export type Err = "Err";
+        export const Err: Err = "Err";
+        export type Info = "Info";
+        export const Info: Info = "Info";
+        export type Perf = "Perf";
+        export const Perf: Perf = "Perf";
+        export type Types = Err | Info | Perf;
+    }
+
    function getProjectRootPath(project: Project): Path {
        switch (project.projectKind) {
            case ProjectKind.Configured:
@@ -115,9 +126,7 @@ namespace ts.server {
    }

    export function createNormalizedPathMap<T>(): NormalizedPathMap<T> {
-/* tslint:disable:no-null-keyword */
        const map = createMap<T>();
-/* tslint:enable:no-null-keyword */
        return {
            get(path) {
                return map.get(path);