multi-line comment formatting fix and handler

src/harness/fourslash.ts

@@ -2500,13 +2500,17 @@ namespace FourSlash {
             }
         }
 
-        public verifyisInMultiLineCommentAtPosition(negative: boolean) {
+        public verifySpanOfEnclosingComment(negative: boolean, onlyMultiLine: boolean) {
             const expected = !negative;
             const position = this.currentCaretPosition;
             const fileName = this.activeFile.fileName;
-            const actual = this.languageService.getisInMultiLineCommentAtPosition(fileName, position);
+            const actual = !!this.languageService.getSpanOfEnclosingComment(fileName, position, /*onlyMultiLine*/ onlyMultiLine);
             if (expected !== actual) {
-                this.raiseError(`verifyIsInDocComment failed: at position '${position}' in '${fileName}', expected '${expected}'.`);
+                this.raiseError(`verifySpanOfEnclosingComment failed:
+                position: '${position}'
+                fileName: '${fileName}'
+                onlyMultiLine: '${onlyMultiLine}'
+                expected: '${expected}'.`);
             }
         }
 
@@ -3583,8 +3587,8 @@ namespace FourSlashInterface {
             this.state.verifyBraceCompletionAtPosition(this.negative, openingBrace);
         }
 
-        public isInMultiLineCommentAtPosition() {
-            this.state.verifyisInMultiLineCommentAtPosition(this.negative);
+        public isInCommentAtPosition(onlyMultiLine: boolean) {
+            this.state.verifySpanOfEnclosingComment(this.negative, onlyMultiLine);
         }
 
         public codeFixAvailable() {

src/harness/harnessLanguageService.ts

@@ -486,8 +486,8 @@ namespace Harness.LanguageService {
         isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean {
             return unwrapJSONCallResult(this.shim.isValidBraceCompletionAtPosition(fileName, position, openingBrace));
         }
-        getisInMultiLineCommentAtPosition(fileName: string, position: number): boolean {
-            return unwrapJSONCallResult(this.shim.getisInMultiLineCommentAtPosition(fileName, position));
+        getSpanOfEnclosingComment(fileName: string, position: number, onlyMultiLine: boolean): ts.TextSpan {
+            return unwrapJSONCallResult(this.shim.getSpanOfEnclosingComment(fileName, position, onlyMultiLine));
         }
         getCodeFixesAtPosition(): ts.CodeAction[] {
             throw new Error("Not supported on the shim.");

src/server/client.ts

@@ -676,7 +676,7 @@ namespace ts.server {
             return notImplemented();
         }
 
-        getisInMultiLineCommentAtPosition(_fileName: string, _position: number): boolean {
+        getSpanOfEnclosingComment(_fileName: string, _position: number, _onlyMultiLine: boolean): TextSpan {
             return notImplemented();
         }
 

src/server/protocol.ts

@@ -8,7 +8,7 @@ namespace ts.server.protocol {
         /* @internal */
         BraceFull = "brace-full",
         BraceCompletion = "braceCompletion",
-        isInMultiLineComment = "isInMultiLineComment",
+        GetSpanOfEnclosingComment = "getSpanOfEnclosingComment",
         Change = "change",
         Close = "close",
         Completions = "completions",
@@ -240,10 +240,18 @@ namespace ts.server.protocol {
     }
 
     /**
-     * A request to determine if the caret is inside a multi-line comment.
+     * A request to determine if the caret is inside a comment.
      */
-    export interface IsInMultiLineCommentAtPositionRequest extends FileLocationRequest {
-        command: CommandTypes.isInMultiLineComment;
+    export interface SpanOfEnclosingCommentRequest extends FileLocationRequest {
+        command: CommandTypes.GetSpanOfEnclosingComment;
+        arguments: SpanOfEnclosingCommentRequestArgs;
+    }
+
+    export interface SpanOfEnclosingCommentRequestArgs extends FileLocationRequestArgs {
+        /**
+         * Requires that the enclosing span be a multi-line comment, or else the request returns undefined.
+         */
+        onlyMultiLine: boolean;
     }
 
     /**

src/server/session.ts

@@ -961,11 +961,12 @@ namespace ts.server {
             return project.getLanguageService(/*ensureSynchronized*/ false).getDocCommentTemplateAtPosition(file, position);
         }
 
-        private getisInMultiLineCommentAtPosition(args: protocol.FileLocationRequestArgs) {
+        private getSpanOfEnclosingComment(args: protocol.SpanOfEnclosingCommentRequestArgs) {
             const { file, project } = this.getFileAndProjectWithoutRefreshingInferredProjects(args);
             const scriptInfo = project.getScriptInfoForNormalizedPath(file);
+            const onlyMultiLine = args.onlyMultiLine;
             const position = this.getPosition(args, scriptInfo);
-            return project.getLanguageService(/*ensureSynchronized*/ false).getisInMultiLineCommentAtPosition(file, position);
+            return project.getLanguageService(/*ensureSynchronized*/ false).getSpanOfEnclosingComment(file, position, onlyMultiLine);
         }
 
         private getIndentation(args: protocol.IndentationRequestArgs) {
@@ -1701,8 +1702,8 @@ namespace ts.server {
             [CommandNames.DocCommentTemplate]: (request: protocol.DocCommentTemplateRequest) => {
                 return this.requiredResponse(this.getDocCommentTemplate(request.arguments));
             },
-            [CommandNames.isInMultiLineComment]: (request: protocol.IsInMultiLineCommentAtPositionRequest) => {
-                return this.requiredResponse(this.getisInMultiLineCommentAtPosition(request.arguments));
+            [CommandNames.GetSpanOfEnclosingComment]: (request: protocol.SpanOfEnclosingCommentRequest) => {
+                return this.requiredResponse(this.getSpanOfEnclosingComment(request.arguments));
             },
             [CommandNames.Format]: (request: protocol.FormatRequest) => {
                 return this.requiredResponse(this.getFormattingEditsForRange(request.arguments));

src/services/formatting/formatting.ts

@@ -1118,23 +1118,37 @@ namespace ts.formatting {
     }
 
     /**
-     * @returns -1 iff the position is not in a multi-line comment.
+     * Gets the indentation level of the multi-line comment enclosing position,
+     * and a negative value if the position is not in a multi-line comment.
      */
-    export function getIndentationOfEnclosingMultiLineComment(sourceFile: SourceFile, position: number): number {
-        const token = getTokenAtPosition(sourceFile, position, /*includeJsDocComment*/ false);
-        const leadingCommentRanges = getLeadingCommentRangesOfNode(token, sourceFile);
-        if (leadingCommentRanges) {
-            loop: for (const range of leadingCommentRanges) {
+    export function getIndentationOfEnclosingMultiLineComment(sourceFile: SourceFile, position: number, options: EditorSettings): number {
+        const range = getRangeOfEnclosingComment(sourceFile, position, /*onlyMultiLine*/ true);
+        if (range) {
+            const commentStart = range.pos;
+            const commentLineStart = getLineStartPositionForPosition(commentStart, sourceFile);
+            const { column, character } = SmartIndenter.findFirstNonWhitespaceCharacterAndColumn(commentLineStart, commentStart, sourceFile, options);
+            return column + /*length after whitespace ends*/ range.pos - (commentLineStart + character);
+        }
+        return undefined;
+    }
+
+    export function getRangeOfEnclosingComment(sourceFile: SourceFile, position: number, onlyMultiLine: boolean): CommentRange | undefined {
+        const precedingToken = findPrecedingToken(position, sourceFile);
+        const trailingRangesOfPreviousToken = precedingToken && getTrailingCommentRanges(sourceFile.text, precedingToken.end);
+        const leadingCommentRangesOfNextToken = getLeadingCommentRangesOfNode(getTokenAtPosition(sourceFile, position, /*includeJsDocComment*/ false), sourceFile);
+        const commentRanges = trailingRangesOfPreviousToken && leadingCommentRangesOfNextToken ?
+            trailingRangesOfPreviousToken.concat(leadingCommentRangesOfNextToken) :
+            trailingRangesOfPreviousToken || leadingCommentRangesOfNextToken;
+        if (commentRanges) {
+            for (const range of commentRanges) {
                 // We need to extend the range when in an unclosed multi-line comment.
-                if (range.pos < position && (position < range.end || position === range.end && position === sourceFile.getFullWidth())) {
-                    if (range.kind === SyntaxKind.MultiLineCommentTrivia) {
-                        return range.pos - getLineStartPositionForPosition(range.pos, sourceFile);
-                    }
-                    break loop;
+                if (range.pos < position && position < range.end ||
+                    position === range.end && (range.kind === SyntaxKind.SingleLineCommentTrivia || position === sourceFile.getFullWidth())) {
+                    return onlyMultiLine && range.kind !== SyntaxKind.MultiLineCommentTrivia ? undefined : range;
                 }
             }
         }
-        return -1;
+        return undefined;
     }
 
 

src/services/formatting/smartIndenter.ts

@@ -44,8 +44,8 @@ namespace ts.formatting {
 
             const lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line;
 
-            const indentationOfEnclosingMultiLineComment = getIndentationOfEnclosingMultiLineComment(sourceFile, position);
-            if (indentationOfEnclosingMultiLineComment !== -1) {
+            const indentationOfEnclosingMultiLineComment = getIndentationOfEnclosingMultiLineComment(sourceFile, position, options);
+            if (indentationOfEnclosingMultiLineComment >= 0) {
                 return indentationOfEnclosingMultiLineComment;
             }
 
@@ -410,13 +410,13 @@ namespace ts.formatting {
             return findFirstNonWhitespaceColumn(lineStart, lineStart + lineAndCharacter.character, sourceFile, options);
         }
 
-        /*
-            Character is the actual index of the character since the beginning of the line.
-            Column - position of the character after expanding tabs to spaces
-            "0\t2$"
-            value of 'character' for '$' is 3
-            value of 'column' for '$' is 6 (assuming that tab size is 4)
-        */
+        /**
+         * Character is the actual index of the character since the beginning of the line.
+         * Column - position of the character after expanding tabs to spaces.
+         * "0\t2$"
+         * value of 'character' for '$' is 3
+         * value of 'column' for '$' is 6 (assuming that tab size is 4)
+         */
         export function findFirstNonWhitespaceCharacterAndColumn(startPos: number, endPos: number, sourceFile: SourceFileLike, options: EditorSettings) {
             let character = 0;
             let column = 0;

src/services/services.ts

@@ -1818,9 +1818,10 @@ namespace ts {
             return true;
         }
 
-        function getisInMultiLineCommentAtPosition(fileName: string, position: number): boolean {
+        function getSpanOfEnclosingComment(fileName: string, position: number, onlyMultiLine: boolean) {
             const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
-            return ts.formatting.getIndentationOfEnclosingMultiLineComment(sourceFile, position) !== -1;
+            const range = ts.formatting.getRangeOfEnclosingComment(sourceFile, position, onlyMultiLine);
+            return range && createTextSpanFromRange(range);
         }
 
         function getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[] {
@@ -2045,7 +2046,7 @@ namespace ts {
             getFormattingEditsAfterKeystroke,
             getDocCommentTemplateAtPosition,
             isValidBraceCompletionAtPosition,
-            getisInMultiLineCommentAtPosition,
+            getSpanOfEnclosingComment,
             getCodeFixesAtPosition,
             getEmitOutput,
             getNonBoundSourceFile,

src/services/shims.ts

@@ -255,9 +255,9 @@ namespace ts {
         isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): string;
 
         /**
-         * Returns JSON-encoded boolean to indicate whether the caret at the current position is in a multi-line comment.
+         * Returns a JSON-encoded TextSpan | undefined indicating the range of the enclosing comment, if it exists.
          */
-        getisInMultiLineCommentAtPosition(fileName: string, position: number): string;
+        getSpanOfEnclosingComment(fileName: string, position: number, onlyMultiLine: boolean): string;
 
         getEmitOutput(fileName: string): string;
         getEmitOutputObject(fileName: string): EmitOutput;
@@ -840,11 +840,10 @@ namespace ts {
             );
         }
 
-        /// GET IS IN MULTI-LINE COMMENT
-        public getisInMultiLineCommentAtPosition(fileName: string, position: number): string {
+        public getSpanOfEnclosingComment(fileName: string, position: number, onlyMultiLine: boolean): string {
             return this.forwardJSONCall(
-                `getisInMultiLineCommentAtPosition('${fileName}', ${position})`,
-                () => this.languageService.getisInMultiLineCommentAtPosition(fileName, position)
+                `getSpanOfEnclosingComment('${fileName}', ${position})`,
+                () => this.languageService.getSpanOfEnclosingComment(fileName, position, onlyMultiLine)
             );
         }
 

src/services/types.ts

@@ -260,7 +260,7 @@ namespace ts {
 
         isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean;
 
-        getisInMultiLineCommentAtPosition(fileName: string, position: number): boolean;
+        getSpanOfEnclosingComment(fileName: string, position: number, onlyMultiLine: boolean): TextSpan;
 
         getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: number[], formatOptions: FormatCodeSettings): CodeAction[];
         getApplicableRefactors(fileName: string, positionOrRaneg: number | TextRange): ApplicableRefactorInfo[];

tests/cases/fourslash/fourslash.ts

@@ -149,7 +149,7 @@ declare namespace FourSlashInterface {
         typeDefinitionCountIs(expectedCount: number): void;
         implementationListIsEmpty(): void;
         isValidBraceCompletionAtPosition(openingBrace?: string): void;
-        isInMultiLineCommentAtPosition(): void;
+        isInCommentAtPosition(onlyMultiLine: boolean): void;
         codeFixAvailable(): void;
         applicableRefactorAvailableAtMarker(markerName: string): void;
         codeFixDiagnosticsAvailableAtMarkers(markerNames: string[], diagnosticCode?: number): void;

tests/cases/fourslash/isInMultiLineComment.ts

@@ -1,36 +1,47 @@
 /// <reference path="fourslash.ts" />
 
 //// /* x */
-//// /** x */
+//// /**
+////   * @param this doesn't make sense here.
+////   */
 //// // x
-//// let x = 1;
-
-
-for (let i = 1; i < 7; ++i) {
-    goTo.position(i);
-    verify.isInMultiLineCommentAtPosition();
-}
-
-for (let i = 0; i < 2; ++i) {
-    goTo.position(i * 7);
-    verify.not.isInMultiLineCommentAtPosition();
-}
-
-const jsDocStart = 8;
-
-for (let i = 1; i < 8; ++i) {
-    goTo.position(jsDocStart + i);
-    verify.isInMultiLineCommentAtPosition();
-}
-
-for (let i = 0; i < 2; ++i) {
-    goTo.position(jsDocStart + i * 8);
-    verify.not.isInMultiLineCommentAtPosition();
-}
-
-const singleLineCommentStart = 17;
-
-for (let i = 0; i < 5; ++i) {
-    goTo.position(singleLineCommentStart + i);
-    verify.not.isInMultiLineCommentAtPosition();
-}
+//// let x = 1; /*
+////             *
+
+const firstCommentStart = 0;
+const firstCommentEnd = 7;
+goTo.position(firstCommentStart);
+verify.not.isInCommentAtPosition(/*onlyMultiLine*/ true);
+
+goTo.position(firstCommentStart + 1);
+verify.isInCommentAtPosition(/*onlyMultiLine*/ true);
+goTo.position(firstCommentEnd - 1);
+verify.isInCommentAtPosition(/*onlyMultiLine*/ true);
+
+goTo.position(firstCommentEnd);
+verify.not.isInCommentAtPosition(/*onlyMultiLine*/ true);
+
+const multilineJsDocStart = firstCommentEnd + 1;
+const multilineJsDocEnd = multilineJsDocStart + 49;
+
+goTo.position(multilineJsDocStart);
+verify.not.isInCommentAtPosition(/*onlyMultiLine*/ true);
+goTo.position(multilineJsDocStart + 1);
+verify.isInCommentAtPosition(/*onlyMultiLine*/ true);
+goTo.position(multilineJsDocEnd - 1);
+verify.isInCommentAtPosition(/*onlyMultiLine*/ true);
+goTo.position(multilineJsDocEnd);
+verify.not.isInCommentAtPosition(/*onlyMultiLine*/ true);
+
+const singleLineCommentStart = multilineJsDocEnd + 1;
+
+goTo.position(singleLineCommentStart + 1);
+verify.not.isInCommentAtPosition(/*onlyMultiLine*/ true);
+verify.isInCommentAtPosition(/*onlyMultiLine*/ false);
+
+const postNodeCommentStart = singleLineCommentStart + 16;
+
+goTo.position(postNodeCommentStart);
+verify.not.isInCommentAtPosition(/*onlyMultiLine*/ true);
+goTo.position(postNodeCommentStart + 1);
+verify.isInCommentAtPosition(/*onlyMultiLine*/ true);