Added comment and uncomment selection

Author: Armando Aguirre

src/harness/client.ts

@@ -3679,6 +3679,28 @@ namespace FourSlash {
 
             this.verifyCurrentFileContent(newFileContent);
         }
+
+        public commentSelection(newFileContent: string): void {
+            let changes: ts.TextChange[] = [];
+            for (let range of this.getRanges()) {
+                changes.push.apply(changes, this.languageService.commentSelection(this.activeFile.fileName, range));
+            }
+
+            this.applyEdits(this.activeFile.fileName, changes);
+
+            this.verifyCurrentFileContent(newFileContent);
+        }
+
+        public uncommentSelection(newFileContent: string): void {
+            let changes: ts.TextChange[] = [];
+            for (let range of this.getRanges()) {
+                changes.push.apply(changes, this.languageService.uncommentSelection(this.activeFile.fileName, range));
+            }
+
+            this.applyEdits(this.activeFile.fileName, changes);
+
+            this.verifyCurrentFileContent(newFileContent);
+        }
     }
 
     function prefixMessage(message: string | undefined) {

src/harness/fourslashImpl.ts

@@ -218,6 +218,14 @@ namespace FourSlashInterface {
         public toggleMultilineComment(newFileContent: string) {
             this.state.toggleMultilineComment(newFileContent);
         }
+
+        public commentSelection(newFileContent: string) {
+            this.state.commentSelection(newFileContent);
+        }
+
+        public uncommentSelection(newFileContent: string) {
+            this.state.uncommentSelection(newFileContent);
+        }
     }
 
     export class Verify extends VerifyNegatable {

src/harness/fourslashInterfaceImpl.ts

@@ -137,10 +137,17 @@ namespace ts.server.protocol {
         /* @internal */
         SelectionRangeFull = "selectionRange-full",
         ToggleLineComment = "toggleLineComment",
+        /* @internal */
         ToggleLineCommentFull = "toggleLineComment-full",
         ToggleMultilineComment = "toggleMultilineComment",
+        /* @internal */
         ToggleMultilineCommentFull = "toggleMultilineComment-full",
-
+        CommentSelection = "commentSelection",
+        /* @internal */
+        CommentSelectionFull = "commentSelection-full",
+        UncommentSelection = "uncommentSelection",
+        /* @internal */
+        UncommentSelectionFull = "uncommentSelection-full",
         PrepareCallHierarchy = "prepareCallHierarchy",
         ProvideCallHierarchyIncomingCalls = "provideCallHierarchyIncomingCalls",
         ProvideCallHierarchyOutgoingCalls = "provideCallHierarchyOutgoingCalls",
@@ -1547,6 +1554,16 @@ namespace ts.server.protocol {
         arguments: FileRangeRequestArgs;
     }
 
+    export interface CommentSelectionRequest extends FileRequest {
+        command: CommandTypes.CommentSelection;
+        arguments: FileRangeRequestArgs;
+    }
+
+    export interface UncommentSelectionRequest extends FileRequest {
+        command: CommandTypes.UncommentSelection;
+        arguments: FileRangeRequestArgs;
+    }
+
     /**
      *  Information found in an "open" request.
      */

src/harness/harnessLanguageService.ts

@@ -2233,6 +2233,38 @@ namespace ts.server {
             return textChanges;
         }
 
+        private commentSelection(args: protocol.FileRangeRequestArgs, simplifiedResult: boolean): TextChange[] | protocol.CodeEdit[] {
+            const { file, project } = this.getFileAndProject(args);
+            const scriptInfo = project.getScriptInfoForNormalizedPath(file)!;
+            const textRange = this.getRange(args, scriptInfo);
+
+            const textChanges = project.getLanguageService().commentSelection(file, textRange);
+
+            if (simplifiedResult) {
+                const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file)!;
+
+                return textChanges.map(textChange => this.convertTextChangeToCodeEdit(textChange, scriptInfo));
+            }
+
+            return textChanges;
+        }
+
+        private uncommentSelection(args: protocol.FileRangeRequestArgs, simplifiedResult: boolean): TextChange[] | protocol.CodeEdit[] {
+            const { file, project } = this.getFileAndProject(args);
+            const scriptInfo = project.getScriptInfoForNormalizedPath(file)!;
+            const textRange = this.getRange(args, scriptInfo);
+
+            const textChanges = project.getLanguageService().uncommentSelection(file, textRange);
+
+            if (simplifiedResult) {
+                const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(file)!;
+
+                return textChanges.map(textChange => this.convertTextChangeToCodeEdit(textChange, scriptInfo));
+            }
+
+            return textChanges;
+        }
+
         private mapSelectionRange(selectionRange: SelectionRange, scriptInfo: ScriptInfo): protocol.SelectionRange {
             const result: protocol.SelectionRange = {
                 textSpan: toProtocolTextSpan(selectionRange.textSpan, scriptInfo),
@@ -2690,6 +2722,18 @@ namespace ts.server {
             [CommandNames.ToggleMultilineCommentFull]: (request: protocol.ToggleMultilineCommentRequest) => {
                 return this.requiredResponse(this.toggleMultilineComment(request.arguments, /*simplifiedResult*/false));
             },
+            [CommandNames.CommentSelection]: (request: protocol.CommentSelectionRequest) => {
+                return this.requiredResponse(this.commentSelection(request.arguments, /*simplifiedResult*/true));
+            },
+            [CommandNames.CommentSelectionFull]: (request: protocol.CommentSelectionRequest) => {
+                return this.requiredResponse(this.commentSelection(request.arguments, /*simplifiedResult*/false));
+            },
+            [CommandNames.UncommentSelection]: (request: protocol.UncommentSelectionRequest) => {
+                return this.requiredResponse(this.uncommentSelection(request.arguments, /*simplifiedResult*/true));
+            },
+            [CommandNames.UncommentSelectionFull]: (request: protocol.UncommentSelectionRequest) => {
+                return this.requiredResponse(this.uncommentSelection(request.arguments, /*simplifiedResult*/false));
+            },
         });
 
         public addProtocolHandler(command: string, handler: (request: protocol.Request) => HandlerResponse) {

src/server/protocol.ts

@@ -1985,12 +1985,12 @@ namespace ts {
             }
         }
 
-        function toggleLineComment(fileName: string, textRange: TextRange): TextChange[] {
+        function toggleLineComment(fileName: string, textRange: TextRange, insertComment?: boolean): TextChange[] {
             const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
             const textChanges: TextChange[] = [];
             const { lineStarts, firstLine, lastLine } = getLinesForRange(sourceFile, textRange);
 
-            let isCommenting = false;
+            let isCommenting = insertComment || false;
             let leftMostPosition = Number.MAX_VALUE;
             let lineTextStarts = new Map<number>();
             const whiteSpaceRegex = new RegExp(/\S/);
@@ -2008,7 +2008,7 @@ namespace ts {
                     lineTextStarts.set(i.toString(), regExec.index);
 
                     if (lineText.substr(regExec.index, openComment.length) !== openComment) {
-                        isCommenting = true;
+                        isCommenting = insertComment !== undefined ? insertComment : true;
                     }
                 }
             }
@@ -2029,7 +2029,7 @@ namespace ts {
                                 start: lineStarts[i] + leftMostPosition
                             }
                         });
-                    } else {
+                    } else if (sourceFile.text.substr(lineStarts[i] + lineTextStart, openComment.length) === openComment) {
                         textChanges.push({
                             newText: "",
                             span: {
@@ -2049,7 +2049,7 @@ namespace ts {
             const textChanges: TextChange[] = [];
             const { text } = sourceFile;
 
-            let isCommenting = insertComment !== undefined ? insertComment : false;
+            let isCommenting = insertComment || false;
             const positions = [] as number[] as SortedArray<number>;
 
             let pos = textRange.pos;
@@ -2083,7 +2083,9 @@ namespace ts {
                 } else { // If it's not in a comment range, then we need to comment the uncommented portions.
                     let newPos = text.substring(pos, textRange.end).search(`(${openMultilineRegex})|(${closeMultilineRegex})`);
 
-                    isCommenting = isCommenting || !isTextWhiteSpaceLike(text, pos, newPos === -1 ? textRange.end : pos + newPos);
+                    isCommenting = insertComment !== undefined
+                        ? insertComment
+                        : isCommenting || !isTextWhiteSpaceLike(text, pos, newPos === -1 ? textRange.end : pos + newPos); // If isCommenting is already true we don't need to check whitespace again.
                     pos = newPos === -1 ? textRange.end + 1 : pos + newPos + closeMultiline.length;
                 }
             }
@@ -2157,6 +2159,31 @@ namespace ts {
             return textChanges;
         }
 
+        function commentSelection(fileName: string, textRange: TextRange): TextChange[] {
+            return toggleLineComment(fileName, textRange, true);
+        }
+        function uncommentSelection(fileName: string, textRange: TextRange): TextChange[] {
+            const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
+            const textChanges: TextChange[] = [];
+
+            for (let i = textRange.pos; i <= textRange.end; i++) {
+                let commentRange = isInComment(sourceFile, i);
+                if (commentRange) {
+                    switch (commentRange.kind) {
+                        case SyntaxKind.SingleLineCommentTrivia:
+                            textChanges.push.apply(textChanges, toggleLineComment(fileName, { end: commentRange.end, pos: commentRange.pos + 1 }, false));
+                            break;
+                        case SyntaxKind.MultiLineCommentTrivia:
+                            textChanges.push.apply(textChanges, toggleMultilineComment(fileName, { end: commentRange.end, pos: commentRange.pos + 1 }, false));
+                    }
+
+                    i = commentRange.end + 1;
+                }
+            }
+
+            return textChanges;
+        }
+
         function isUnclosedTag({ openingElement, closingElement, parent }: JsxElement): boolean {
             return !tagNamesAreEquivalent(openingElement.tagName, closingElement.tagName) ||
                 isJsxElement(parent) && tagNamesAreEquivalent(openingElement.tagName, parent.openingElement.tagName) && isUnclosedTag(parent);
@@ -2437,7 +2464,9 @@ namespace ts {
             provideCallHierarchyIncomingCalls,
             provideCallHierarchyOutgoingCalls,
             toggleLineComment,
-            toggleMultilineComment
+            toggleMultilineComment,
+            commentSelection,
+            uncommentSelection,
         };
     }
 

src/server/session.ts

@@ -280,6 +280,8 @@ namespace ts {
 
         toggleLineComment(fileName: string, textChange: ts.TextRange): string;
         toggleMultilineComment(fileName: string, textChange: ts.TextRange): string;
+        commentSelection(fileName: string, textChange: ts.TextRange): string;
+        uncommentSelection(fileName: string, textChange: ts.TextRange): string;
     }
 
     export interface ClassifierShim extends Shim {
@@ -1083,6 +1085,20 @@ namespace ts {
                 () => this.languageService.toggleMultilineComment(fileName, textRange)
             );
         }
+
+        public commentSelection(fileName: string, textRange: ts.TextRange): string {
+            return this.forwardJSONCall(
+                `commentSelection('${fileName}', '${JSON.stringify(textRange)}')`,
+                () => this.languageService.commentSelection(fileName, textRange)
+            );
+        }
+
+        public uncommentSelection(fileName: string, textRange: ts.TextRange): string {
+            return this.forwardJSONCall(
+                `uncommentSelection('${fileName}', '${JSON.stringify(textRange)}')`,
+                () => this.languageService.uncommentSelection(fileName, textRange)
+            );
+        }
     }
 
     function convertClassifications(classifications: Classifications): { spans: string, endOfLineState: EndOfLineState } {

src/services/services.ts

@@ -488,6 +488,8 @@ namespace ts {
 
         toggleLineComment(fileName: string, textRanges: TextRange): TextChange[];
         toggleMultilineComment(fileName: string, textRanges: TextRange): TextChange[];
+        commentSelection(fileName: string, textRanges: TextRange): TextChange[];
+        uncommentSelection(fileName: string, textRanges: TextRange): TextChange[];
 
         dispose(): void;
     }

src/services/shims.ts

@@ -273,7 +273,9 @@ namespace ts.server {
                 CommandNames.ProvideCallHierarchyIncomingCalls,
                 CommandNames.ProvideCallHierarchyOutgoingCalls,
                 CommandNames.ToggleLineComment,
-                CommandNames.ToggleMultilineComment
+                CommandNames.ToggleMultilineComment,
+                CommandNames.CommentSelection,
+                CommandNames.UncommentSelection,
             ];
 
             it("should not throw when commands are executed with invalid arguments", () => {