code stringlengths 24 2.07M | docstring stringlengths 25 85.3k | func_name stringlengths 1 92 | language stringclasses 1
value | repo stringlengths 5 64 | path stringlengths 4 172 | url stringlengths 44 218 | license stringclasses 7
values |
|---|---|---|---|---|---|---|---|
function checkJsxSelfClosingElement(node) {
checkJsxOpeningLikeElement(node);
return jsxElementType || anyType;
} | Detect if the mapper implies an inference context. Specifically, there are 4 possible values
for a mapper. Let's go through each one of them:
1. undefined - this means we are not doing inferential typing, but we may do contextual typing,
which could cause us to assign a parameter a type
2. identityMapper -... | checkJsxSelfClosingElement | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function tagNamesAreEquivalent(lhs, rhs) {
if (lhs.kind !== rhs.kind) {
return false;
}
if (lhs.kind === 69 /* Identifier */) {
return lhs.text === rhs.text;
}
return lhs.right.text === rhs.right.text &&
tagNames... | Detect if the mapper implies an inference context. Specifically, there are 4 possible values
for a mapper. Let's go through each one of them:
1. undefined - this means we are not doing inferential typing, but we may do contextual typing,
which could cause us to assign a parameter a type
2. identityMapper -... | tagNamesAreEquivalent | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkJsxElement(node) {
// Check attributes
checkJsxOpeningLikeElement(node.openingElement);
// Check that the closing tag matches
if (!tagNamesAreEquivalent(node.openingElement.tagName, node.closingElement.tagName)) {
error(node.closingElement, t... | Detect if the mapper implies an inference context. Specifically, there are 4 possible values
for a mapper. Let's go through each one of them:
1. undefined - this means we are not doing inferential typing, but we may do contextual typing,
which could cause us to assign a parameter a type
2. identityMapper -... | checkJsxElement | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isUnhyphenatedJsxName(name) {
// - is the only character supported in JSX attribute names that isn't valid in JavaScript identifiers
return name.indexOf("-") < 0;
} | Returns true iff the JSX element name would be a valid JS identifier, ignoring restrictions about keywords not being identifiers | isUnhyphenatedJsxName | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getJsxElementPropertiesName() {
// JSX
var jsxNamespace = getGlobalSymbol(JsxNames.JSX, 1536 /* Namespace */, /*diagnosticMessage*/ undefined);
// JSX.ElementAttributesProperty [symbol]
var attribsPropTypeSym = jsxNamespace && getSymbol(jsxNamespace.exports, JsxN... | Given a JSX element that is a class element, finds the Element Instance Type. If the
element is not a class element, or the class element type cannot be determined, returns 'undefined'.
For example, in the element <MyClass>, the element instance type is `MyClass` (not `typeof MyClass`). | getJsxElementPropertiesName | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getJsxGlobalElementClassType() {
if (!jsxElementClassType) {
jsxElementClassType = getExportedTypeFromNamespace(JsxNames.JSX, JsxNames.ElementClass);
}
return jsxElementClassType;
} | Given a JSX attribute, returns the symbol for the corresponds property
of the element attributes type. Will return unknownSymbol for attributes
that have no matching element attributes type property. | getJsxGlobalElementClassType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getJsxIntrinsicTagNames() {
var intrinsics = getJsxIntrinsicElementsType();
return intrinsics ? getPropertiesOfType(intrinsics) : emptyArray;
} | Given a JSX attribute, returns the symbol for the corresponds property
of the element attributes type. Will return unknownSymbol for attributes
that have no matching element attributes type property. | getJsxIntrinsicTagNames | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkJsxPreconditions(errorNode) {
// Preconditions for using JSX
if ((compilerOptions.jsx || 0 /* None */) === 0 /* None */) {
error(errorNode, ts.Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided);
}
if (jsxElementType === undefined) {
... | Given a JSX attribute, returns the symbol for the corresponds property
of the element attributes type. Will return unknownSymbol for attributes
that have no matching element attributes type property. | checkJsxPreconditions | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkJsxOpeningLikeElement(node) {
checkGrammarJsxElement(node);
checkJsxPreconditions(node);
// If we're compiling under --jsx react, the symbol 'React' should
// be marked as 'used' so we don't incorrectly elide its import. And if there
// is no 'Re... | Given a JSX attribute, returns the symbol for the corresponds property
of the element attributes type. Will return unknownSymbol for attributes
that have no matching element attributes type property. | checkJsxOpeningLikeElement | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkJsxExpression(node) {
if (node.expression) {
return checkExpression(node.expression);
}
else {
return unknownType;
}
} | Given a JSX attribute, returns the symbol for the corresponds property
of the element attributes type. Will return unknownSymbol for attributes
that have no matching element attributes type property. | checkJsxExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getDeclarationKindFromSymbol(s) {
return s.valueDeclaration ? s.valueDeclaration.kind : 141 /* PropertyDeclaration */;
} | Given a JSX attribute, returns the symbol for the corresponds property
of the element attributes type. Will return unknownSymbol for attributes
that have no matching element attributes type property. | getDeclarationKindFromSymbol | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getDeclarationFlagsFromSymbol(s) {
return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : s.flags & 134217728 /* Prototype */ ? 8 /* Public */ | 64 /* Static */ : 0;
} | Given a JSX attribute, returns the symbol for the corresponds property
of the element attributes type. Will return unknownSymbol for attributes
that have no matching element attributes type property. | getDeclarationFlagsFromSymbol | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkClassPropertyAccess(node, left, type, prop) {
var flags = getDeclarationFlagsFromSymbol(prop);
var declaringClass = getDeclaredTypeOfSymbol(prop.parent);
if (left.kind === 95 /* SuperKeyword */) {
var errorNode = node.kind === 166 /* PropertyAccessExpres... | Check whether the requested property access is valid.
Returns true if node is a valid property access, and false otherwise.
@param node The node to be checked.
@param left The left hand side of the property access (e.g.: the super in `super.foo`).
@param type The type of left.
@param prop The symbol for the right hand ... | checkClassPropertyAccess | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkPropertyAccessExpression(node) {
return checkPropertyAccessExpressionOrQualifiedName(node, node.expression, node.name);
} | Check whether the requested property access is valid.
Returns true if node is a valid property access, and false otherwise.
@param node The node to be checked.
@param left The left hand side of the property access (e.g.: the super in `super.foo`).
@param type The type of left.
@param prop The symbol for the right hand ... | checkPropertyAccessExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkQualifiedName(node) {
return checkPropertyAccessExpressionOrQualifiedName(node, node.left, node.right);
} | Check whether the requested property access is valid.
Returns true if node is a valid property access, and false otherwise.
@param node The node to be checked.
@param left The left hand side of the property access (e.g.: the super in `super.foo`).
@param type The type of left.
@param prop The symbol for the right hand ... | checkQualifiedName | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkPropertyAccessExpressionOrQualifiedName(node, left, right) {
var type = checkExpression(left);
if (isTypeAny(type)) {
return type;
}
var apparentType = getApparentType(getWidenedType(type));
if (apparentType === unknownType) {
... | Check whether the requested property access is valid.
Returns true if node is a valid property access, and false otherwise.
@param node The node to be checked.
@param left The left hand side of the property access (e.g.: the super in `super.foo`).
@param type The type of left.
@param prop The symbol for the right hand ... | checkPropertyAccessExpressionOrQualifiedName | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isValidPropertyAccess(node, propertyName) {
var left = node.kind === 166 /* PropertyAccessExpression */
? node.expression
: node.left;
var type = checkExpression(left);
if (type !== unknownType && !isTypeAny(type)) {
var prop =... | Check whether the requested property access is valid.
Returns true if node is a valid property access, and false otherwise.
@param node The node to be checked.
@param left The left hand side of the property access (e.g.: the super in `super.foo`).
@param type The type of left.
@param prop The symbol for the right hand ... | isValidPropertyAccess | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkIndexedAccess(node) {
// Grammar checking
if (!node.argumentExpression) {
var sourceFile = getSourceFile(node);
if (node.parent.kind === 169 /* NewExpression */ && node.parent.expression === node) {
var start = ts.skipTrivia(sourc... | Check whether the requested property access is valid.
Returns true if node is a valid property access, and false otherwise.
@param node The node to be checked.
@param left The left hand side of the property access (e.g.: the super in `super.foo`).
@param type The type of left.
@param prop The symbol for the right hand ... | checkIndexedAccess | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getEffectiveDecoratorFirstArgumentType(node) {
// The first argument to a decorator is its `target`.
if (node.kind === 214 /* ClassDeclaration */) {
// For a class decorator, the `target` is the type of the class (e.g. the
// "static" or "constructor" sid... | Returns the effective type of the first argument to a decorator.
If 'node' is a class declaration or class expression, the effective argument type
is the type of the static side of the class.
If 'node' is a parameter declaration, the effective argument type is either the type
of the static or instance side of the... | getEffectiveDecoratorFirstArgumentType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getEffectiveDecoratorThirdArgumentType(node) {
// The third argument to a decorator is either its `descriptor` for a method decorator
// or its `parameterIndex` for a paramter decorator
if (node.kind === 214 /* ClassDeclaration */) {
ts.Debug.fail("Class deco... | Returns the effective argument type for the third argument to a decorator.
If 'node' is a parameter, the effective argument type is the number type.
If 'node' is a method or accessor, the effective argument type is a
`TypedPropertyDescriptor<T>` instantiated with the type of the member.
Class and property decorators... | getEffectiveDecoratorThirdArgumentType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function resolveCall(node, signatures, candidatesOutArray, headMessage) {
var isTaggedTemplate = node.kind === 170 /* TaggedTemplateExpression */;
var isDecorator = node.kind === 139 /* Decorator */;
var typeArguments;
if (!isTaggedTemplate && !isDecorator) {
... | Gets the error node to use when reporting errors for an effective argument. | resolveCall | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function reportError(message, arg0, arg1, arg2) {
var errorInfo;
errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2);
if (headMessage) {
errorInfo = ts.chainDiagnosticMessages(errorInfo, headMessage);
}
... | Gets the error node to use when reporting errors for an effective argument. | reportError | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function chooseOverload(candidates, relation) {
for (var _i = 0, candidates_2 = candidates; _i < candidates_2.length; _i++) {
var originalCandidate = candidates_2[_i];
if (!hasCorrectArity(node, args, originalCandidate)) {
continue;
... | Gets the error node to use when reporting errors for an effective argument. | chooseOverload | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function resolveCallExpression(node, candidatesOutArray) {
if (node.expression.kind === 95 /* SuperKeyword */) {
var superType = checkSuperExpression(node.expression);
if (superType !== unknownType) {
// In super call, the candidate signatures are the matc... | Gets the error node to use when reporting errors for an effective argument. | resolveCallExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function resolveNewExpression(node, candidatesOutArray) {
if (node.arguments && languageVersion < 1 /* ES5 */) {
var spreadIndex = getSpreadArgumentIndex(node.arguments);
if (spreadIndex >= 0) {
error(node.arguments[spreadIndex], ts.Diagnostics.Spread_oper... | Gets the error node to use when reporting errors for an effective argument. | resolveNewExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function resolveTaggedTemplateExpression(node, candidatesOutArray) {
var tagType = checkExpression(node.tag);
var apparentType = getApparentType(tagType);
if (apparentType === unknownType) {
// Another error has already been reported
return resolveErro... | Gets the error node to use when reporting errors for an effective argument. | resolveTaggedTemplateExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkCallExpression(node) {
// Grammar checking; stop grammar-checking if checkGrammarTypeArguments return true
checkGrammarTypeArguments(node, node.typeArguments) || checkGrammarArguments(node, node.arguments);
var signature = getResolvedSignature(node);
if (nod... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkCallExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkTaggedTemplateExpression(node) {
return getReturnTypeOfSignature(getResolvedSignature(node));
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkTaggedTemplateExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkAssertion(node) {
var exprType = getRegularTypeOfObjectLiteral(checkExpression(node.expression));
var targetType = getTypeFromTypeNode(node.type);
if (produceDiagnostics && targetType !== unknownType) {
var widenedType = getWidenedType(exprType);
... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkAssertion | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypeAtPosition(signature, pos) {
return signature.hasRestParameter ?
pos < signature.parameters.length - 1 ? getTypeOfSymbol(signature.parameters[pos]) : getRestTypeOfSignature(signature) :
pos < signature.parameters.length ? getTypeOfSymbol(signature.parameters[p... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | getTypeAtPosition | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function assignContextualParameterTypes(signature, context, mapper) {
var len = signature.parameters.length - (signature.hasRestParameter ? 1 : 0);
for (var i = 0; i < len; i++) {
var parameter = signature.parameters[i];
var contextualParameterType = getTypeAtPosi... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | assignContextualParameterTypes | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function assignTypeToParameterAndFixTypeParameters(parameter, contextualType, mapper) {
var links = getSymbolLinks(parameter);
if (!links.type) {
links.type = instantiateType(contextualType, mapper);
assignBindingElementTypes(parameter.valueDeclaration);
... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | assignTypeToParameterAndFixTypeParameters | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function createPromiseType(promisedType) {
// creates a `Promise<T>` type where `T` is the promisedType argument
var globalPromiseType = getGlobalPromiseType();
if (globalPromiseType !== emptyGenericType) {
// if the promised type is itself a promise, get the underlyi... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | createPromiseType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getReturnTypeFromBody(func, contextualMapper) {
var contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func);
if (!func.body) {
return unknownType;
}
var isAsync = ts.isAsyncFunctionLike(func);
var type;
... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | getReturnTypeFromBody | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkAndAggregateYieldOperandTypes(body, contextualMapper) {
var aggregatedTypes = [];
ts.forEachYieldExpression(body, function (yieldExpression) {
var expr = yieldExpression.expression;
if (expr) {
var type = checkExpressionCached(exp... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkAndAggregateYieldOperandTypes | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkAndAggregateReturnExpressionTypes(body, contextualMapper, isAsync) {
var aggregatedTypes = [];
ts.forEachReturnStatement(body, function (returnStatement) {
var expr = returnStatement.expression;
if (expr) {
var type = checkExpress... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkAndAggregateReturnExpressionTypes | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) {
if (!produceDiagnostics) {
return;
}
// Functions that return 'void' or 'any' don't need any return expressions.
if (returnType === voidType || isTypeAny(returnType)) {
... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkAllCodePathsInNonVoidFunctionReturnOrThrow | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper) {
ts.Debug.assert(node.kind !== 143 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node));
// Grammar checking
var hasGrammarError = checkGrammarFunctionLikeDeclaration(node);
if (!hasGramm... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkFunctionExpressionOrObjectLiteralMethod | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkFunctionExpressionOrObjectLiteralMethodBody(node) {
ts.Debug.assert(node.kind !== 143 /* MethodDeclaration */ || ts.isObjectLiteralMethod(node));
var isAsync = ts.isAsyncFunctionLike(node);
if (isAsync) {
emitAwaiter = true;
}
var... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkFunctionExpressionOrObjectLiteralMethodBody | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkArithmeticOperandType(operand, type, diagnostic) {
if (!isTypeAnyOrAllConstituentTypesHaveKind(type, 132 /* NumberLike */)) {
error(operand, diagnostic);
return false;
}
return true;
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkArithmeticOperandType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkReferenceExpression(n, invalidReferenceMessage, constantVariableMessage) {
function findSymbol(n) {
var symbol = getNodeLinks(n).resolvedSymbol;
// Because we got the symbol from the resolvedSymbol property, it might be of kind
// SymbolFlags.Exp... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkReferenceExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function findSymbol(n) {
var symbol = getNodeLinks(n).resolvedSymbol;
// Because we got the symbol from the resolvedSymbol property, it might be of kind
// SymbolFlags.ExportValue. In this case it is necessary to get the actual export
// symbol, which will... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | findSymbol | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isReferenceOrErrorExpression(n) {
// TypeScript 1.0 spec (April 2014):
// Expressions are classified as values or references.
// References are the subset of expressions that are permitted as the target of an assignment.
// Specifically, reference... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | isReferenceOrErrorExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isConstVariableReference(n) {
switch (n.kind) {
case 69 /* Identifier */:
case 166 /* PropertyAccessExpression */: {
var symbol = findSymbol(n);
return symbol && (symbol.flags & 3 /* Variable */) !== 0 && (g... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | isConstVariableReference | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkDeleteExpression(node) {
checkExpression(node.expression);
return booleanType;
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkDeleteExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkTypeOfExpression(node) {
checkExpression(node.expression);
return stringType;
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkTypeOfExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkVoidExpression(node) {
checkExpression(node.expression);
return undefinedType;
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkVoidExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkAwaitExpression(node) {
// Grammar checking
if (produceDiagnostics) {
if (!(node.parserContextFlags & 8 /* Await */)) {
grammarErrorOnFirstToken(node, ts.Diagnostics.await_expression_is_only_allowed_within_an_async_function);
}
... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkAwaitExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkPrefixUnaryExpression(node) {
var operandType = checkExpression(node.operand);
switch (node.operator) {
case 35 /* PlusToken */:
case 36 /* MinusToken */:
case 50 /* TildeToken */:
if (someConstituentTypeHasKind(op... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkPrefixUnaryExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkPostfixUnaryExpression(node) {
var operandType = checkExpression(node.operand);
var ok = checkArithmeticOperandType(node.operand, operandType, ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_or_an_enum_type);
if (ok) {
// run check only i... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkPostfixUnaryExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function someConstituentTypeHasKind(type, kind) {
if (type.flags & kind) {
return true;
}
if (type.flags & 49152 /* UnionOrIntersection */) {
var types = type.types;
for (var _i = 0, types_9 = types; _i < types_9.length; _i++) {
... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | someConstituentTypeHasKind | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function allConstituentTypesHaveKind(type, kind) {
if (type.flags & kind) {
return true;
}
if (type.flags & 49152 /* UnionOrIntersection */) {
var types = type.types;
for (var _i = 0, types_10 = types; _i < types_10.length; _i++) {
... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | allConstituentTypesHaveKind | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isConstEnumObjectType(type) {
return type.flags & (80896 /* ObjectType */ | 65536 /* Anonymous */) && type.symbol && isConstEnumSymbol(type.symbol);
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | isConstEnumObjectType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isConstEnumSymbol(symbol) {
return (symbol.flags & 128 /* ConstEnum */) !== 0;
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | isConstEnumSymbol | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkInstanceOfExpression(left, right, leftType, rightType) {
// TypeScript 1.0 spec (April 2014): 4.15.4
// The instanceof operator requires the left operand to be of type Any, an object type, or a type parameter type,
// and the right operand to be of type Any or a subtype... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkInstanceOfExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkInExpression(left, right, leftType, rightType) {
// TypeScript 1.0 spec (April 2014): 4.15.5
// The in operator requires the left operand to be of type Any, the String primitive type, or the Number primitive type,
// and the right operand to be of type Any, an object ty... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkInExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkObjectLiteralAssignment(node, sourceType, contextualMapper) {
var properties = node.properties;
for (var _i = 0, properties_3 = properties; _i < properties_3.length; _i++) {
var p = properties_3[_i];
if (p.kind === 245 /* PropertyAssignment */ || p.k... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkObjectLiteralAssignment | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkArrayLiteralAssignment(node, sourceType, contextualMapper) {
// This elementType will be used if the specific property corresponding to this index is not
// present (aka the tuple element property). This call also checks that the parentType is in
// fact an iterable or ... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkArrayLiteralAssignment | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkDestructuringAssignment(exprOrAssignment, sourceType, contextualMapper) {
var target;
if (exprOrAssignment.kind === 246 /* ShorthandPropertyAssignment */) {
var prop = exprOrAssignment;
if (prop.objectAssignmentInitializer) {
chec... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkDestructuringAssignment | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkReferenceAssignment(target, sourceType, contextualMapper) {
var targetType = checkExpression(target, contextualMapper);
if (checkReferenceExpression(target, ts.Diagnostics.Invalid_left_hand_side_of_assignment_expression, ts.Diagnostics.Left_hand_side_of_assignment_expression_cannot... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkReferenceAssignment | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkBinaryExpression(node, contextualMapper) {
return checkBinaryLikeExpression(node.left, node.operatorToken, node.right, contextualMapper, node);
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkBinaryExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkBinaryLikeExpression(left, operatorToken, right, contextualMapper, errorNode) {
var operator = operatorToken.kind;
if (operator === 56 /* EqualsToken */ && (left.kind === 165 /* ObjectLiteralExpression */ || left.kind === 164 /* ArrayLiteralExpression */)) {
return ... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkBinaryLikeExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkForDisallowedESSymbolOperand(operator) {
var offendingSymbolOperand = someConstituentTypeHasKind(leftType, 16777216 /* ESSymbol */) ? left :
someConstituentTypeHasKind(rightType, 16777216 /* ESSymbol */) ? right :
undefined;
if (o... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkForDisallowedESSymbolOperand | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getSuggestedBooleanOperator(operator) {
switch (operator) {
case 47 /* BarToken */:
case 67 /* BarEqualsToken */:
return 52 /* BarBarToken */;
case 48 /* CaretToken */:
case 68 /* CaretEquals... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | getSuggestedBooleanOperator | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkAssignmentOperator(valueType) {
if (produceDiagnostics && operator >= 56 /* FirstAssignment */ && operator <= 68 /* LastAssignment */) {
// TypeScript 1.0 spec (April 2014): 4.17
// An assignment of the form
// VarExpr = ValueE... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkAssignmentOperator | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function reportOperatorError() {
error(errorNode || operatorToken, ts.Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2, ts.tokenToString(operatorToken.kind), typeToString(leftType), typeToString(rightType));
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | reportOperatorError | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isYieldExpressionInClass(node) {
var current = node;
var parent = node.parent;
while (parent) {
if (ts.isFunctionLike(parent) && current === parent.body) {
return false;
}
else if (ts.isClassLike(current)) {... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | isYieldExpressionInClass | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkYieldExpression(node) {
// Grammar checking
if (produceDiagnostics) {
if (!(node.parserContextFlags & 2 /* Yield */) || isYieldExpressionInClass(node)) {
grammarErrorOnFirstToken(node, ts.Diagnostics.A_yield_expression_is_only_allowed_in_a_genera... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkYieldExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkConditionalExpression(node, contextualMapper) {
checkExpression(node.condition);
var type1 = checkExpression(node.whenTrue, contextualMapper);
var type2 = checkExpression(node.whenFalse, contextualMapper);
return getUnionType([type1, type2]);
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkConditionalExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkStringLiteralExpression(node) {
var contextualType = getContextualType(node);
if (contextualType && contextualTypeIsStringLiteralType(contextualType)) {
return getStringLiteralType(node);
}
return stringType;
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkStringLiteralExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkTemplateExpression(node) {
// We just want to check each expressions, but we are unconcerned with
// the type of each expression, as any value may be coerced into a string.
// It is worth asking whether this is what we really want though.
// A place where we... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkTemplateExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkExpressionWithContextualType(node, contextualType, contextualMapper) {
var saveContextualType = node.contextualType;
node.contextualType = contextualType;
var result = checkExpression(node, contextualMapper);
node.contextualType = saveContextualType;
... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkExpressionWithContextualType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkExpressionCached(node, contextualMapper) {
var links = getNodeLinks(node);
if (!links.resolvedType) {
links.resolvedType = checkExpression(node, contextualMapper);
}
return links.resolvedType;
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkExpressionCached | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkPropertyAssignment(node, contextualMapper) {
// Do not use hasDynamicName here, because that returns false for well known symbols.
// We want to perform checkComputedPropertyName for all computed properties, including
// well known symbols.
if (node.name.kin... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkPropertyAssignment | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkObjectLiteralMethod(node, contextualMapper) {
// Grammar checking
checkGrammarMethod(node);
// Do not use hasDynamicName here, because that returns false for well known symbols.
// We want to perform checkComputedPropertyName for all computed properties, inc... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkObjectLiteralMethod | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function instantiateTypeWithSingleGenericCallSignature(node, type, contextualMapper) {
if (isInferentialContext(contextualMapper)) {
var signature = getSingleCallSignature(type);
if (signature && signature.typeParameters) {
var contextualType = getApparent... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | instantiateTypeWithSingleGenericCallSignature | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkExpression(node, contextualMapper) {
var type;
if (node.kind === 135 /* QualifiedName */) {
type = checkQualifiedName(node);
}
else {
var uninstantiatedType = checkExpressionWorker(node, contextualMapper);
type... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkNumericLiteral(node) {
// Grammar checking
checkGrammarNumericLiteral(node);
return numberType;
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkNumericLiteral | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkExpressionWorker(node, contextualMapper) {
switch (node.kind) {
case 69 /* Identifier */:
return checkIdentifier(node);
case 97 /* ThisKeyword */:
return checkThisExpression(node);
case 95 /* SuperKeyword *... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkExpressionWorker | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkParameter(node) {
// Grammar checking
// It is a SyntaxError if the Identifier "eval" or the Identifier "arguments" occurs as the
// Identifier in a PropertySetParameterList of a PropertyAssignment that is contained in strict code
// or if its FunctionBody i... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkParameter | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isSyntacticallyValidGenerator(node) {
if (!node.asteriskToken || !node.body) {
return false;
}
return node.kind === 143 /* MethodDeclaration */ ||
node.kind === 213 /* FunctionDeclaration */ ||
node.kind === 173 /* FunctionExpr... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | isSyntacticallyValidGenerator | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypePredicateParameterIndex(parameterList, parameter) {
if (parameterList) {
for (var i = 0; i < parameterList.length; i++) {
var param = parameterList[i];
if (param.name.kind === 69 /* Identifier */ &&
param.name.te... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | getTypePredicateParameterIndex | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isInLegalTypePredicatePosition(node) {
switch (node.parent.kind) {
case 174 /* ArrowFunction */:
case 147 /* CallSignature */:
case 213 /* FunctionDeclaration */:
case 173 /* FunctionExpression */:
case 152 /* FunctionT... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | isInLegalTypePredicatePosition | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkSignatureDeclaration(node) {
// Grammar checking
if (node.kind === 149 /* IndexSignature */) {
checkGrammarIndexSignature(node);
}
else if (node.kind === 152 /* FunctionType */ || node.kind === 213 /* FunctionDeclaration */ || node.kind === 1... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkSignatureDeclaration | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkTypeForDuplicateIndexSignatures(node) {
if (node.kind === 215 /* InterfaceDeclaration */) {
var nodeSymbol = getSymbolOfNode(node);
// in case of merging interface declaration it is possible that we'll enter this check procedure several times for every declarati... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkTypeForDuplicateIndexSignatures | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkPropertyDeclaration(node) {
// Grammar checking
checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarProperty(node) || checkGrammarComputedPropertyName(node.name);
checkVariableLikeDeclaration(node);
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkPropertyDeclaration | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkMethodDeclaration(node) {
// Grammar checking
checkGrammarMethod(node) || checkGrammarComputedPropertyName(node.name);
// Grammar checking for modifiers is done inside the function checkGrammarFunctionLikeDeclaration
checkFunctionLikeDeclaration(node);
... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkMethodDeclaration | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkConstructorDeclaration(node) {
// Grammar check on signature of constructor and modifier of the constructor is done in checkSignatureDeclaration function.
checkSignatureDeclaration(node);
// Grammar check for checking only related to constructoDeclaration
ch... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkConstructorDeclaration | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isSuperCallExpression(n) {
return n.kind === 168 /* CallExpression */ && n.expression.kind === 95 /* SuperKeyword */;
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | isSuperCallExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function containsSuperCallAsComputedPropertyName(n) {
return n.name && containsSuperCall(n.name);
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | containsSuperCallAsComputedPropertyName | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function containsSuperCall(n) {
if (isSuperCallExpression(n)) {
return true;
}
else if (ts.isFunctionLike(n)) {
return false;
}
else if (ts.isClassLike(n)) {
return ts.forEach(n.me... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | containsSuperCall | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function markThisReferencesAsErrors(n) {
if (n.kind === 97 /* ThisKeyword */) {
error(n, ts.Diagnostics.this_cannot_be_referenced_in_current_location);
}
else if (n.kind !== 173 /* FunctionExpression */ && n.kind !== 213 /* FunctionDeclaration */) {
... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | markThisReferencesAsErrors | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isInstancePropertyWithInitializer(n) {
return n.kind === 141 /* PropertyDeclaration */ &&
!(n.flags & 64 /* Static */) &&
!!n.initializer;
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | isInstancePropertyWithInitializer | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkAccessorDeclaration(node) {
if (produceDiagnostics) {
// Grammar checking accessors
checkGrammarFunctionLikeDeclaration(node) || checkGrammarAccessor(node) || checkGrammarComputedPropertyName(node.name);
if (node.kind === 145 /* GetAccessor */) {... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkAccessorDeclaration | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkTypeArgumentConstraints(typeParameters, typeArguments) {
var result = true;
for (var i = 0; i < typeParameters.length; i++) {
var constraint = getConstraintOfTypeParameter(typeParameters[i]);
if (constraint) {
var typeArgument = t... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkTypeArgumentConstraints | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkTypeReferenceNode(node) {
checkGrammarTypeArguments(node, node.typeArguments);
var type = getTypeFromTypeReference(node);
if (type !== unknownType && node.typeArguments) {
// Do type argument local checks only if referenced type is successfully resolved
... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkTypeReferenceNode | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkTypeLiteral(node) {
ts.forEach(node.members, checkSourceElement);
if (produceDiagnostics) {
var type = getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
checkIndexConstraints(type);
checkTypeForDuplicateIndexSignatures(node... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkTypeLiteral | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkTupleType(node) {
// Grammar checking
var hasErrorFromDisallowedTrailingComma = checkGrammarForDisallowedTrailingComma(node.elementTypes);
if (!hasErrorFromDisallowedTrailingComma && node.elementTypes.length === 0) {
grammarErrorOnNode(node, ts.Diagnosti... | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkTupleType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkUnionOrIntersectionType(node) {
ts.forEach(node.types, checkSourceElement);
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | checkUnionOrIntersectionType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isPrivateWithinAmbient(node) {
return (node.flags & 16 /* Private */) && ts.isInAmbientContext(node);
} | Syntactically and semantically checks a call or new expression.
@param node The call/new expression to be checked.
@returns On success, the expression's signature's return type. On failure, anyType. | isPrivateWithinAmbient | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.