| "use strict"; |
| |
| Object.defineProperty(exports, "__esModule", { |
| value: true |
| }); |
| exports.default = _default; |
| |
| var t = _interopRequireWildcard(require("@babel/types")); |
| |
| function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; } |
| |
| function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; if (obj != null) { var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } |
| |
| function _default(node) { |
| if (!this.isReferenced()) return; |
| const binding = this.scope.getBinding(node.name); |
| |
| if (binding) { |
| if (binding.identifier.typeAnnotation) { |
| return binding.identifier.typeAnnotation; |
| } else { |
| return getTypeAnnotationBindingConstantViolations(binding, this, node.name); |
| } |
| } |
| |
| if (node.name === "undefined") { |
| return t.voidTypeAnnotation(); |
| } else if (node.name === "NaN" || node.name === "Infinity") { |
| return t.numberTypeAnnotation(); |
| } else if (node.name === "arguments") {} |
| } |
| |
| function getTypeAnnotationBindingConstantViolations(binding, path, name) { |
| const types = []; |
| const functionConstantViolations = []; |
| let constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations); |
| const testType = getConditionalAnnotation(binding, path, name); |
| |
| if (testType) { |
| const testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement); |
| constantViolations = constantViolations.filter(path => testConstantViolations.indexOf(path) < 0); |
| types.push(testType.typeAnnotation); |
| } |
| |
| if (constantViolations.length) { |
| constantViolations = constantViolations.concat(functionConstantViolations); |
| |
| for (const violation of constantViolations) { |
| types.push(violation.getTypeAnnotation()); |
| } |
| } |
| |
| if (types.length) { |
| return t.createUnionTypeAnnotation(types); |
| } |
| } |
| |
| function getConstantViolationsBefore(binding, path, functions) { |
| const violations = binding.constantViolations.slice(); |
| violations.unshift(binding.path); |
| return violations.filter(violation => { |
| violation = violation.resolve(); |
| |
| const status = violation._guessExecutionStatusRelativeTo(path); |
| |
| if (functions && status === "unknown") functions.push(violation); |
| return status === "before"; |
| }); |
| } |
| |
| function inferAnnotationFromBinaryExpression(name, path) { |
| const operator = path.node.operator; |
| const right = path.get("right").resolve(); |
| const left = path.get("left").resolve(); |
| let target; |
| |
| if (left.isIdentifier({ |
| name |
| })) { |
| target = right; |
| } else if (right.isIdentifier({ |
| name |
| })) { |
| target = left; |
| } |
| |
| if (target) { |
| if (operator === "===") { |
| return target.getTypeAnnotation(); |
| } |
| |
| if (t.BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) { |
| return t.numberTypeAnnotation(); |
| } |
| |
| return; |
| } |
| |
| if (operator !== "===" && operator !== "==") return; |
| let typeofPath; |
| let typePath; |
| |
| if (left.isUnaryExpression({ |
| operator: "typeof" |
| })) { |
| typeofPath = left; |
| typePath = right; |
| } else if (right.isUnaryExpression({ |
| operator: "typeof" |
| })) { |
| typeofPath = right; |
| typePath = left; |
| } |
| |
| if (!typeofPath) return; |
| if (!typeofPath.get("argument").isIdentifier({ |
| name |
| })) return; |
| typePath = typePath.resolve(); |
| if (!typePath.isLiteral()) return; |
| const typeValue = typePath.node.value; |
| if (typeof typeValue !== "string") return; |
| return t.createTypeAnnotationBasedOnTypeof(typeValue); |
| } |
| |
| function getParentConditionalPath(binding, path, name) { |
| let parentPath; |
| |
| while (parentPath = path.parentPath) { |
| if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) { |
| if (path.key === "test") { |
| return; |
| } |
| |
| return parentPath; |
| } |
| |
| if (parentPath.isFunction()) { |
| if (parentPath.parentPath.scope.getBinding(name) !== binding) return; |
| } |
| |
| path = parentPath; |
| } |
| } |
| |
| function getConditionalAnnotation(binding, path, name) { |
| const ifStatement = getParentConditionalPath(binding, path, name); |
| if (!ifStatement) return; |
| const test = ifStatement.get("test"); |
| const paths = [test]; |
| const types = []; |
| |
| for (let i = 0; i < paths.length; i++) { |
| const path = paths[i]; |
| |
| if (path.isLogicalExpression()) { |
| if (path.node.operator === "&&") { |
| paths.push(path.get("left")); |
| paths.push(path.get("right")); |
| } |
| } else if (path.isBinaryExpression()) { |
| const type = inferAnnotationFromBinaryExpression(name, path); |
| if (type) types.push(type); |
| } |
| } |
| |
| if (types.length) { |
| return { |
| typeAnnotation: t.createUnionTypeAnnotation(types), |
| ifStatement |
| }; |
| } |
| |
| return getConditionalAnnotation(ifStatement, name); |
| } |