ce4c83ff
 wxy
初始提交
|
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.getTypeAnnotation = getTypeAnnotation;
exports._getTypeAnnotation = _getTypeAnnotation;
exports.isBaseType = isBaseType;
exports.couldBeBaseType = couldBeBaseType;
exports.baseTypeStrictlyMatches = baseTypeStrictlyMatches;
exports.isGenericType = isGenericType;
var inferers = _interopRequireWildcard(require("./inferers"));
function t() {
var data = _interopRequireWildcard(require("@babel/types"));
t = function t() {
return data;
};
return data;
}
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
function getTypeAnnotation() {
if (this.typeAnnotation) return this.typeAnnotation;
var type = this._getTypeAnnotation() || t().anyTypeAnnotation();
if (t().isTypeAnnotation(type)) type = type.typeAnnotation;
return this.typeAnnotation = type;
}
function _getTypeAnnotation() {
var node = this.node;
if (!node) {
if (this.key === "init" && this.parentPath.isVariableDeclarator()) {
var declar = this.parentPath.parentPath;
var declarParent = declar.parentPath;
if (declar.key === "left" && declarParent.isForInStatement()) {
return t().stringTypeAnnotation();
}
if (declar.key === "left" && declarParent.isForOfStatement()) {
return t().anyTypeAnnotation();
}
return t().voidTypeAnnotation();
} else {
return;
}
}
if (node.typeAnnotation) {
return node.typeAnnotation;
}
var inferer = inferers[node.type];
if (inferer) {
return inferer.call(this, node);
}
inferer = inferers[this.parentPath.type];
if (inferer && inferer.validParent) {
return this.parentPath.getTypeAnnotation();
}
}
function isBaseType(baseName, soft) {
return _isBaseType(baseName, this.getTypeAnnotation(), soft);
}
function _isBaseType(baseName, type, soft) {
if (baseName === "string") {
return t().isStringTypeAnnotation(type);
} else if (baseName === "number") {
return t().isNumberTypeAnnotation(type);
} else if (baseName === "boolean") {
return t().isBooleanTypeAnnotation(type);
} else if (baseName === "any") {
return t().isAnyTypeAnnotation(type);
} else if (baseName === "mixed") {
return t().isMixedTypeAnnotation(type);
} else if (baseName === "empty") {
return t().isEmptyTypeAnnotation(type);
} else if (baseName === "void") {
return t().isVoidTypeAnnotation(type);
} else {
if (soft) {
return false;
} else {
throw new Error("Unknown base type " + baseName);
}
}
}
function couldBeBaseType(name) {
var type = this.getTypeAnnotation();
if (t().isAnyTypeAnnotation(type)) return true;
if (t().isUnionTypeAnnotation(type)) {
var _arr = type.types;
for (var _i = 0; _i < _arr.length; _i++) {
var type2 = _arr[_i];
if (t().isAnyTypeAnnotation(type2) || _isBaseType(name, type2, true)) {
return true;
}
}
return false;
} else {
return _isBaseType(name, type, true);
}
}
function baseTypeStrictlyMatches(right) {
var left = this.getTypeAnnotation();
right = right.getTypeAnnotation();
if (!t().isAnyTypeAnnotation(left) && t().isFlowBaseAnnotation(left)) {
return right.type === left.type;
}
}
function isGenericType(genericName) {
var type = this.getTypeAnnotation();
return t().isGenericTypeAnnotation(type) && t().isIdentifier(type.id, {
name: genericName
});
}
|
