forked from palantir/tslint
/
restrictPlusOperandsRule.ts
116 lines (107 loc) · 4.44 KB
/
restrictPlusOperandsRule.ts
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
/**
* @license
* Copyright 2018 Palantir Technologies, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import { isBinaryExpression, isTypeFlagSet, isUnionType } from "tsutils";
import * as ts from "typescript";
import * as Lint from "../index";
export class Rule extends Lint.Rules.TypedRule {
/* tslint:disable:object-literal-sort-keys */
public static metadata: Lint.IRuleMetadata = {
ruleName: "restrict-plus-operands",
description:
"When adding two variables, operands must both be of type number or of type string.",
optionsDescription: "Not configurable.",
options: null,
optionExamples: [true],
type: "functionality",
typescriptOnly: false,
requiresTypeInfo: true,
};
/* tslint:enable:object-literal-sort-keys */
public static INVALID_TYPES_ERROR =
"Operands of '+' operation must either be both strings or both numbers or both bigints";
public static SUGGEST_TEMPLATE_LITERALS = ". Consider using template literals.";
public applyWithProgram(sourceFile: ts.SourceFile, program: ts.Program): Lint.RuleFailure[] {
return this.applyWithFunction(sourceFile, walk, undefined, program.getTypeChecker());
}
}
function walk(ctx: Lint.WalkContext, tc: ts.TypeChecker) {
return ts.forEachChild(ctx.sourceFile, function cb(node: ts.Node): void {
if (isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
const leftType = tc.getTypeAtLocation(node.left);
const leftTypeStr = getBaseTypeOfLiteralType(leftType);
const rightType = tc.getTypeAtLocation(node.right);
const rightTypeStr = getBaseTypeOfLiteralType(rightType);
if (
leftTypeStr === "invalid" ||
rightTypeStr === "invalid" ||
leftTypeStr !== rightTypeStr
) {
const actualTypes = `, but found ${getTypeString(
tc,
node.left,
leftType,
)} + ${getTypeString(tc, node.right, rightType)}`;
let message = Rule.INVALID_TYPES_ERROR + actualTypes;
if (leftTypeStr === "string" || rightTypeStr === "string") {
message += Rule.SUGGEST_TEMPLATE_LITERALS;
}
return ctx.addFailureAtNode(node, message);
}
}
return ts.forEachChild(node, cb);
});
}
function getTypeString(tc: ts.TypeChecker, node: ts.Node, type: ts.Type) {
const typeString = tc.typeToString(type, node);
if (
typeString === "undefined[]" &&
ts.isArrayLiteralExpression(node) &&
node.elements.length === 0
) {
// Special case literal "[]" arrays that would otherwise be emitted as undefined[].
return "[]";
}
return typeString;
}
function getBaseTypeOfLiteralType(type: ts.Type): "string" | "number" | "bigint" | "invalid" {
if (
isTypeFlagSet(type, ts.TypeFlags.StringLiteral) ||
isTypeFlagSet(type, ts.TypeFlags.String)
) {
return "string";
} else if (
isTypeFlagSet(type, ts.TypeFlags.NumberLiteral) ||
isTypeFlagSet(type, ts.TypeFlags.Number)
) {
return "number";
} else if (
isTypeFlagSet(type, ts.TypeFlags.BigIntLiteral) ||
isTypeFlagSet(type, ts.TypeFlags.BigInt)
) {
return "bigint";
} else if (isUnionType(type) && !isTypeFlagSet(type, ts.TypeFlags.Enum)) {
const types = type.types.map(getBaseTypeOfLiteralType);
return allSame(types) ? types[0] : "invalid";
} else if (isTypeFlagSet(type, ts.TypeFlags.EnumLiteral)) {
// Compatibility for TypeScript pre-2.4, which used EnumLiteralType instead of LiteralType
getBaseTypeOfLiteralType(((type as any) as { baseType: ts.LiteralType }).baseType);
}
return "invalid";
}
function allSame(array: string[]) {
return array.every(value => value === array[0]);
}