Add "inline-comment-spacing" lint rule

Author: Andy Hanson

scripts/tslint/inlineCommentSpacingRule.ts

@@ -0,0 +1,98 @@
+import assert = require("assert");
+import * as Lint from "tslint/lib";
+import * as ts from "typescript";
+
+export class Rule extends Lint.Rules.AbstractRule {
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithFunction(sourceFile, ctx => walk(ctx));
+    }
+}
+
+function walk(ctx: Lint.WalkContext<void>): void {
+    const { sourceFile } = ctx;
+    const { text } = sourceFile;
+    forEachComment(sourceFile, (node, { pos, end, kind }) => {
+        if (kind !== ts.SyntaxKind.MultiLineCommentTrivia) {
+            return;
+        }
+
+        const startLine = sourceFile.getLineAndCharacterOfPosition(pos).line;
+        const endLine = sourceFile.getLineAndCharacterOfPosition(end).line;
+        if (startLine !== endLine) {
+            return;
+        }
+
+        assert(text[pos] === "/");
+        assert(text[pos + 1] === "*");
+        assert(text[end - 2] === "*");
+        assert(text[end - 1] === "/");
+        const trailingWhitespace = text[end - 3] === " ";
+        if (inCallExpressionArgument(node)) {
+            const leadingWhitespace = text[pos + 2] === " ";
+            if (leadingWhitespace) {
+                fail(pos + 2, "/*comment*/ should not start with space");
+            }
+            if (trailingWhitespace) {
+                fail(end - 3, "/*comment*/ should not end with space");
+            }
+        }
+        else {
+            // TODO: this causes a lot of errors -- we're not consistent about whether statement comments should have spaces.
+            /*
+            const startPos = text[pos + 2] === "*" ? pos + 3 : pos + 2;
+            const leadingWhitespace = text[startPos] === " ";
+            if (!leadingWhitespace) {
+                fail(startPos, "/* comment * / should start with space");
+            }
+            if (!trailingWhitespace) {
+                fail(end - 3, "/* comment * / should end in space");
+            }
+            */
+        }
+    });
+
+    function fail(pos: number, reason: string): void {
+        ctx.addFailure(pos, pos + 1, reason);
+    }
+}
+
+function inCallExpressionArgument(node: ts.Node): boolean {
+    const { parent } = node;
+    if (!parent) {
+        return false;
+    }
+
+    switch (parent.kind) {
+        case ts.SyntaxKind.CallExpression:
+            return (parent as ts.CallExpression).expression !== node;
+        case ts.SyntaxKind.Block:
+        case ts.SyntaxKind.ModuleBlock:
+        case ts.SyntaxKind.CaseBlock:
+            return false;
+        default:
+            return inCallExpressionArgument(parent);
+    }
+}
+
+function forEachComment(sourceFile: ts.SourceFile, cb: (node: ts.Node, comment: ts.CommentRange) => void): void {
+    const { text } = sourceFile;
+    sourceFile.forEachChild(function recur(node) {
+        const leading = ts.getLeadingCommentRanges(text, node.pos);
+        if (leading) {
+            for (const range of leading) {
+                cb(node, range);
+            }
+        }
+        const trailing = ts.getTrailingCommentRanges(text, node.pos);
+        if (trailing) {
+            for (const range of trailing) {
+                cb(node, range);
+            }
+        }
+        node.forEachChild(recur);
+    });
+}
+
+
+
+

src/compiler/checker.ts

@@ -12446,7 +12446,7 @@ namespace ts {
         function checkThisExpression(node: Node): Type {
             // Stop at the first arrow function so that we can
             // tell whether 'this' needs to be captured.
-            let container = getThisContainer(node, /* includeArrowFunctions */ true);
+            let container = getThisContainer(node, /*includeArrowFunctions*/ true);
             let needToCaptureLexicalThis = false;
 
             if (container.kind === SyntaxKind.Constructor) {
@@ -12455,7 +12455,7 @@ namespace ts {
 
             // Now skip arrow functions to get the "real" owner of 'this'.
             if (container.kind === SyntaxKind.ArrowFunction) {
-                container = getThisContainer(container, /* includeArrowFunctions */ false);
+                container = getThisContainer(container, /*includeArrowFunctions*/ false);
 
                 // When targeting es6, arrow function lexically bind "this" so we do not need to do the work of binding "this" in emitted code
                 needToCaptureLexicalThis = (languageVersion < ScriptTarget.ES2015);

src/compiler/commandLineParser.ts

@@ -1148,8 +1148,8 @@ namespace ts {
                     }
                     else {
                         return convertObjectLiteralExpressionToJson(
-                            objectLiteralExpression, /* knownOptions*/ undefined,
-                            /*extraKeyDiagnosticMessage */ undefined, /*parentOption*/ undefined);
+                            objectLiteralExpression, /*knownOptions*/ undefined,
+                            /*extraKeyDiagnosticMessage*/ undefined, /*parentOption*/ undefined);
                     }
 
                 case SyntaxKind.ArrayLiteralExpression:

src/compiler/scanner.ts

@@ -1443,7 +1443,7 @@ namespace ts {
                         }
                         else if (pos + 2 < end && (text.charCodeAt(pos + 1) === CharacterCodes.B || text.charCodeAt(pos + 1) === CharacterCodes.b)) {
                             pos += 2;
-                            let value = scanBinaryOrOctalDigits(/* base */ 2);
+                            let value = scanBinaryOrOctalDigits(/*base*/ 2);
                             if (value < 0) {
                                 error(Diagnostics.Binary_digit_expected);
                                 value = 0;
@@ -1454,7 +1454,7 @@ namespace ts {
                         }
                         else if (pos + 2 < end && (text.charCodeAt(pos + 1) === CharacterCodes.O || text.charCodeAt(pos + 1) === CharacterCodes.o)) {
                             pos += 2;
-                            let value = scanBinaryOrOctalDigits(/* base */ 8);
+                            let value = scanBinaryOrOctalDigits(/*base*/ 8);
                             if (value < 0) {
                                 error(Diagnostics.Octal_digit_expected);
                                 value = 0;

src/compiler/tsc.ts

@@ -117,7 +117,7 @@ namespace ts {
 
         if (commandLine.options.locale) {
             if (!isJSONSupported()) {
-                reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--locale"), /* host */ undefined);
+                reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--locale"), /*host*/ undefined);
                 return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
             }
             validateLocaleAndSetLanguage(commandLine.options.locale, sys, commandLine.errors);
@@ -148,26 +148,26 @@ namespace ts {
 
         if (commandLine.options.project) {
             if (!isJSONSupported()) {
-                reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--project"), /* host */ undefined);
+                reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--project"), /*host*/ undefined);
                 return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
             }
             if (commandLine.fileNames.length !== 0) {
-                reportDiagnostic(createCompilerDiagnostic(Diagnostics.Option_project_cannot_be_mixed_with_source_files_on_a_command_line), /* host */ undefined);
+                reportDiagnostic(createCompilerDiagnostic(Diagnostics.Option_project_cannot_be_mixed_with_source_files_on_a_command_line), /*host*/ undefined);
                 return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
             }
 
             const fileOrDirectory = normalizePath(commandLine.options.project);
             if (!fileOrDirectory /* current directory "." */ || sys.directoryExists(fileOrDirectory)) {
                 configFileName = combinePaths(fileOrDirectory, "tsconfig.json");
                 if (!sys.fileExists(configFileName)) {
-                    reportDiagnostic(createCompilerDiagnostic(Diagnostics.Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0, commandLine.options.project), /* host */ undefined);
+                    reportDiagnostic(createCompilerDiagnostic(Diagnostics.Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0, commandLine.options.project), /*host*/ undefined);
                     return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
                 }
             }
             else {
                 configFileName = fileOrDirectory;
                 if (!sys.fileExists(configFileName)) {
-                    reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_specified_path_does_not_exist_Colon_0, commandLine.options.project), /* host */ undefined);
+                    reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_specified_path_does_not_exist_Colon_0, commandLine.options.project), /*host*/ undefined);
                     return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
                 }
             }
@@ -185,7 +185,7 @@ namespace ts {
 
         if (isWatchSet(commandLine.options)) {
             if (!sys.watchFile) {
-                reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--watch"), /* host */ undefined);
+                reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--watch"), /*host*/ undefined);
                 return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
             }
             if (configFileName) {
@@ -218,21 +218,21 @@ namespace ts {
             }
             if (!cachedConfigFileText) {
                 const error = createCompilerDiagnostic(Diagnostics.File_0_not_found, configFileName);
-                reportDiagnostics([error], /* compilerHost */ undefined);
+                reportDiagnostics([error], /*compilerHost*/ undefined);
                 sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
                 return;
             }
 
             const result = parseJsonText(configFileName, cachedConfigFileText);
-            reportDiagnostics(result.parseDiagnostics, /* compilerHost */ undefined);
+            reportDiagnostics(result.parseDiagnostics, /*compilerHost*/ undefined);
 
             const cwd = sys.getCurrentDirectory();
             const configParseResult = parseJsonSourceFileConfigFileContent(result, sys, getNormalizedAbsolutePath(getDirectoryPath(configFileName), cwd), commandLine.options, getNormalizedAbsolutePath(configFileName, cwd));
-            reportDiagnostics(configParseResult.errors, /* compilerHost */ undefined);
+            reportDiagnostics(configParseResult.errors, /*compilerHost*/ undefined);
 
             if (isWatchSet(configParseResult.options)) {
                 if (!sys.watchFile) {
-                    reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--watch"), /* host */ undefined);
+                    reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--watch"), /*host*/ undefined);
                     sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);
                 }
 
@@ -654,11 +654,11 @@ namespace ts {
         const currentDirectory = sys.getCurrentDirectory();
         const file = normalizePath(combinePaths(currentDirectory, "tsconfig.json"));
         if (sys.fileExists(file)) {
-            reportDiagnostic(createCompilerDiagnostic(Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file), /* host */ undefined);
+            reportDiagnostic(createCompilerDiagnostic(Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file), /*host*/ undefined);
         }
         else {
             sys.writeFile(file, generateTSConfig(options, fileNames, sys.newLine));
-            reportDiagnostic(createCompilerDiagnostic(Diagnostics.Successfully_created_a_tsconfig_json_file), /* host */ undefined);
+            reportDiagnostic(createCompilerDiagnostic(Diagnostics.Successfully_created_a_tsconfig_json_file), /*host*/ undefined);
         }
 
         return;

src/harness/fourslash.ts

@@ -332,7 +332,7 @@ namespace FourSlash {
                 ts.forEach(referencedFiles, referenceFile => {
                     // Fourslash insert tests/cases/fourslash into inputFile.unitName so we will properly append the same base directory to refFile path
                     const referenceFilePath = this.basePath + "/" + referenceFile.fileName;
-                    this.addMatchedInputFile(referenceFilePath, /* extensions */ undefined);
+                    this.addMatchedInputFile(referenceFilePath, /*extensions*/ undefined);
                 });
 
                 // Add import files into language-service host
@@ -2222,10 +2222,7 @@ namespace FourSlash {
 
         public verifyProjectInfo(expected: string[]) {
             if (this.testType === FourSlashTestType.Server) {
-                const actual = (<ts.server.SessionClient>this.languageService).getProjectInfo(
-                    this.activeFile.fileName,
-                    /* needFileNameList */ true
-                );
+                const actual = (<ts.server.SessionClient>this.languageService).getProjectInfo(this.activeFile.fileName, /*needFileNameList*/ true);
                 assert.equal(
                     expected.join(","),
                     actual.fileNames.map(file => {

src/harness/harnessLanguageService.ts

@@ -239,7 +239,7 @@ namespace Harness.LanguageService {
         getHost() { return this.host; }
         getLanguageService(): ts.LanguageService { return ts.createLanguageService(this.host); }
         getClassifier(): ts.Classifier { return ts.createClassifier(); }
-        getPreProcessedFileInfo(fileName: string, fileContents: string): ts.PreProcessedFileInfo { return ts.preProcessFile(fileContents, /* readImportFiles */ true, ts.hasJavaScriptFileExtension(fileName)); }
+        getPreProcessedFileInfo(fileName: string, fileContents: string): ts.PreProcessedFileInfo { return ts.preProcessFile(fileContents, /*readImportFiles*/ true, ts.hasJavaScriptFileExtension(fileName)); }
     }
 
     /// Shim adapter

src/harness/rwcRunner.ts

@@ -138,7 +138,7 @@ namespace RWC {
                     const output = Harness.Compiler.compileFiles(
                         inputFiles,
                         otherFiles,
-                        /* harnessOptions */ undefined,
+                        /*harnessOptions*/ undefined,
                         opts.options,
                         // Since each RWC json file specifies its current directory in its json file, we need
                         // to pass this information in explicitly instead of acquiring it from the process.

src/harness/test262Runner.ts

@@ -55,9 +55,9 @@ class Test262BaselineRunner extends RunnerBase {
                 const output = Harness.Compiler.compileFiles(
                     [Test262BaselineRunner.helperFile].concat(inputFiles),
                     /*otherFiles*/ [],
-                    /* harnessOptions */ undefined,
+                    /*harnessOptions*/ undefined,
                     Test262BaselineRunner.options,
-                    /* currentDirectory */ undefined
+                    /*currentDirectory*/ undefined
                     );
                 testState.compilerResult = output.result;
             });

src/harness/unittests/cachingInServerLSHost.ts

@@ -61,7 +61,7 @@ namespace ts {
             typingsInstaller: undefined
         };
         const projectService = new server.ProjectService(svcOpts);
-        const rootScriptInfo = projectService.getOrCreateScriptInfo(rootFile, /* openedByClient */ true, /*containingProject*/ undefined);
+        const rootScriptInfo = projectService.getOrCreateScriptInfo(rootFile, /*openedByClient*/ true, /*containingProject*/ undefined);
 
         const project = projectService.createInferredProjectWithRootFileIfNecessary(rootScriptInfo);
         project.setCompilerOptions({ module: ts.ModuleKind.AMD, noLib: true } );