FilesExpand file tree

 typeOperations

/

booleanTriviaRule.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

96 lines (88 loc) · 3.5 KB

 typeOperations

/

booleanTriviaRule.ts

Copy path

Top

File metadata and controls

• Code
• Blame

96 lines (88 loc) · 3.5 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

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;

ts.forEachChild(sourceFile, function recur(node: ts.Node): void {

if (node.kind === ts.SyntaxKind.CallExpression) {

checkCall(node as ts.CallExpression);

}

ts.forEachChild(node, recur);

});

function checkCall(node: ts.CallExpression): void {

if (!shouldIgnoreCalledExpression(node.expression)) {

for (const arg of node.arguments) {

checkArg(arg);

}

}

}

/** Skip certain function/method names whose parameter names are not informative. */

function shouldIgnoreCalledExpression(expression: ts.Expression): boolean {

if (expression.kind === ts.SyntaxKind.PropertyAccessExpression) {

const methodName = (expression as ts.PropertyAccessExpression).name.text as string;

if (methodName.indexOf("set") === 0) {

return true;

}

switch (methodName) {

case "apply":

case "assert":

case "assertEqual":

case "call":

case "equal":

case "fail":

case "isTrue":

case "output":

case "stringify":

return true;

}

}

else if (expression.kind === ts.SyntaxKind.Identifier) {

const functionName = (expression as ts.Identifier).text as string;

if (functionName.indexOf("set") === 0) {

return true;

}

switch (functionName) {

case "assert":

case "contains":

case "createAnonymousType":

case "createImportSpecifier":

case "createProperty":

case "createSignature":

case "resolveName":

return true;

}

}

return false;

}

function checkArg(arg: ts.Expression): void {

if (!isTrivia(arg)) {

return;

}

const ranges = ts.getTrailingCommentRanges(sourceFile.text, arg.pos) || ts.getLeadingCommentRanges(sourceFile.text, arg.pos);

if (ranges === undefined || ranges.length !== 1 || ranges[0].kind !== ts.SyntaxKind.MultiLineCommentTrivia) {

ctx.addFailureAtNode(arg, "Tag argument with parameter name");

return;

}

const range = ranges[0];

const argStart = arg.getStart(sourceFile);

if (range.end + 1 !== argStart && sourceFile.text.slice(range.end, argStart).indexOf("\n") === -1) {

ctx.addFailureAtNode(arg, "There should be 1 space between an argument and its comment.");

}

}

function isTrivia(arg: ts.Expression): boolean {

switch (arg.kind) {

case ts.SyntaxKind.TrueKeyword:

case ts.SyntaxKind.FalseKeyword:

case ts.SyntaxKind.NullKeyword:

return true;

case ts.SyntaxKind.Identifier:

return (arg as ts.Identifier).originalKeywordKind === ts.SyntaxKind.UndefinedKeyword;

default:

return false;

}

}

}