| "use strict"; |
| |
| exports.__esModule = true; |
| |
| var _getIterator2 = require("babel-runtime/core-js/get-iterator"); |
| |
| var _getIterator3 = _interopRequireDefault(_getIterator2); |
| |
| exports.default = function (node) { |
| if (!this.isReferenced()) return; |
| |
| var binding = this.scope.getBinding(node.name); |
| if (binding) { |
| if (binding.identifier.typeAnnotation) { |
| return binding.identifier.typeAnnotation; |
| } else { |
| return getTypeAnnotationBindingConstantViolations(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") {} |
| }; |
| |
| var _babelTypes = require("babel-types"); |
| |
| var t = _interopRequireWildcard(_babelTypes); |
| |
| 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)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } } |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| function getTypeAnnotationBindingConstantViolations(path, name) { |
| var binding = path.scope.getBinding(name); |
| |
| var types = []; |
| path.typeAnnotation = t.unionTypeAnnotation(types); |
| |
| var functionConstantViolations = []; |
| var constantViolations = getConstantViolationsBefore(binding, path, functionConstantViolations); |
| |
| var testType = getConditionalAnnotation(path, name); |
| if (testType) { |
| var testConstantViolations = getConstantViolationsBefore(binding, testType.ifStatement); |
| |
| constantViolations = constantViolations.filter(function (path) { |
| return testConstantViolations.indexOf(path) < 0; |
| }); |
| |
| types.push(testType.typeAnnotation); |
| } |
| |
| if (constantViolations.length) { |
| constantViolations = constantViolations.concat(functionConstantViolations); |
| |
| for (var _iterator = constantViolations, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : (0, _getIterator3.default)(_iterator);;) { |
| var _ref; |
| |
| if (_isArray) { |
| if (_i >= _iterator.length) break; |
| _ref = _iterator[_i++]; |
| } else { |
| _i = _iterator.next(); |
| if (_i.done) break; |
| _ref = _i.value; |
| } |
| |
| var violation = _ref; |
| |
| types.push(violation.getTypeAnnotation()); |
| } |
| } |
| |
| if (types.length) { |
| return t.createUnionTypeAnnotation(types); |
| } |
| } |
| |
| function getConstantViolationsBefore(binding, path, functions) { |
| var violations = binding.constantViolations.slice(); |
| violations.unshift(binding.path); |
| return violations.filter(function (violation) { |
| violation = violation.resolve(); |
| var status = violation._guessExecutionStatusRelativeTo(path); |
| if (functions && status === "function") functions.push(violation); |
| return status === "before"; |
| }); |
| } |
| |
| function inferAnnotationFromBinaryExpression(name, path) { |
| var operator = path.node.operator; |
| |
| var right = path.get("right").resolve(); |
| var left = path.get("left").resolve(); |
| |
| var target = void 0; |
| if (left.isIdentifier({ name: name })) { |
| target = right; |
| } else if (right.isIdentifier({ name: name })) { |
| target = left; |
| } |
| if (target) { |
| if (operator === "===") { |
| return target.getTypeAnnotation(); |
| } else if (t.BOOLEAN_NUMBER_BINARY_OPERATORS.indexOf(operator) >= 0) { |
| return t.numberTypeAnnotation(); |
| } else { |
| return; |
| } |
| } else { |
| if (operator !== "===") return; |
| } |
| |
| var typeofPath = void 0; |
| var typePath = void 0; |
| if (left.isUnaryExpression({ operator: "typeof" })) { |
| typeofPath = left; |
| typePath = right; |
| } else if (right.isUnaryExpression({ operator: "typeof" })) { |
| typeofPath = right; |
| typePath = left; |
| } |
| if (!typePath && !typeofPath) return; |
| |
| typePath = typePath.resolve(); |
| if (!typePath.isLiteral()) return; |
| |
| var typeValue = typePath.node.value; |
| if (typeof typeValue !== "string") return; |
| |
| if (!typeofPath.get("argument").isIdentifier({ name: name })) return; |
| |
| return t.createTypeAnnotationBasedOnTypeof(typePath.node.value); |
| } |
| |
| function getParentConditionalPath(path) { |
| var parentPath = void 0; |
| while (parentPath = path.parentPath) { |
| if (parentPath.isIfStatement() || parentPath.isConditionalExpression()) { |
| if (path.key === "test") { |
| return; |
| } else { |
| return parentPath; |
| } |
| } else { |
| path = parentPath; |
| } |
| } |
| } |
| |
| function getConditionalAnnotation(path, name) { |
| var ifStatement = getParentConditionalPath(path); |
| if (!ifStatement) return; |
| |
| var test = ifStatement.get("test"); |
| var paths = [test]; |
| var types = []; |
| |
| do { |
| var _path = paths.shift().resolve(); |
| |
| if (_path.isLogicalExpression()) { |
| paths.push(_path.get("left")); |
| paths.push(_path.get("right")); |
| } |
| |
| if (_path.isBinaryExpression()) { |
| var type = inferAnnotationFromBinaryExpression(name, _path); |
| if (type) types.push(type); |
| } |
| } while (paths.length); |
| |
| if (types.length) { |
| return { |
| typeAnnotation: t.createUnionTypeAnnotation(types), |
| ifStatement: ifStatement |
| }; |
| } else { |
| return getConditionalAnnotation(ifStatement, name); |
| } |
| } |
| module.exports = exports["default"]; |