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 checkStrictModeDeleteExpression(node) {
// Grammar checking
if (inStrictMode && node.expression.kind === 69 /* Identifier */) {
// When a delete operator occurs within strict mode code, a SyntaxError is thrown if its
// UnaryExpression is a direct referen... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | checkStrictModeDeleteExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isEvalOrArgumentsIdentifier(node) {
return node.kind === 69 /* Identifier */ &&
(node.text === "eval" || node.text === "arguments");
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | isEvalOrArgumentsIdentifier | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkStrictModeEvalOrArguments(contextNode, name) {
if (name && name.kind === 69 /* Identifier */) {
var identifier = name;
if (isEvalOrArgumentsIdentifier(identifier)) {
// We check first if the name is inside class declaration or class expressio... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | checkStrictModeEvalOrArguments | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getStrictModeEvalOrArgumentsMessage(node) {
// Provide specialized messages to help the user understand why we think they're in
// strict mode.
if (ts.getContainingClass(node)) {
return ts.Diagnostics.Invalid_use_of_0_Class_definitions_are_automatically_in_st... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | getStrictModeEvalOrArgumentsMessage | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkStrictModeFunctionName(node) {
if (inStrictMode) {
// It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a strict mode FunctionDeclaration or FunctionExpression (13.1))
checkStrictModeEvalOrArguments(node, node.name);... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | checkStrictModeFunctionName | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkStrictModeNumericLiteral(node) {
if (inStrictMode && node.flags & 32768 /* OctalLiteral */) {
file.bindDiagnostics.push(ts.createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode));
}
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | checkStrictModeNumericLiteral | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkStrictModePostfixUnaryExpression(node) {
// Grammar checking
// The identifier eval or arguments may not appear as the LeftHandSideExpression of an
// Assignment operator(11.13) or of a PostfixExpression(11.3) or as the UnaryExpression
// operated upon by a ... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | checkStrictModePostfixUnaryExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkStrictModePrefixUnaryExpression(node) {
// Grammar checking
if (inStrictMode) {
if (node.operator === 41 /* PlusPlusToken */ || node.operator === 42 /* MinusMinusToken */) {
checkStrictModeEvalOrArguments(node, node.operand);
}
... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | checkStrictModePrefixUnaryExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkStrictModeWithStatement(node) {
// Grammar checking for withStatement
if (inStrictMode) {
errorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode);
}
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | checkStrictModeWithStatement | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function errorOnFirstToken(node, message, arg0, arg1, arg2) {
var span = ts.getSpanOfTokenAtPosition(file, node.pos);
file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2));
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | errorOnFirstToken | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getDestructuringParameterName(node) {
return "__" + ts.indexOf(node.parent.parameters, node);
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | getDestructuringParameterName | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bind(node) {
if (!node) {
return;
}
node.parent = parent;
var savedInStrictMode = inStrictMode;
if (!savedInStrictMode) {
updateStrictMode(node);
}
// First we bind declaration nodes to a symbol ... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bind | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function updateStrictMode(node) {
switch (node.kind) {
case 248 /* SourceFile */:
case 219 /* ModuleBlock */:
updateStrictModeStatementList(node.statements);
return;
case 192 /* Block */:
if (ts.isFun... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | updateStrictMode | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function updateStrictModeStatementList(statements) {
for (var _i = 0, statements_1 = statements; _i < statements_1.length; _i++) {
var statement = statements_1[_i];
if (!ts.isPrologueDirective(statement)) {
return;
}
if (isU... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | updateStrictModeStatementList | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isUseStrictPrologueDirective(node) {
var nodeText = ts.getTextOfNodeFromSourceText(file.text, node.expression);
// Note: the node text must be exactly "use strict" or 'use strict'. It is not ok for the
// string to contain unicode escapes (as per ES5).
return no... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | isUseStrictPrologueDirective | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindWorker(node) {
switch (node.kind) {
/* Strict mode checks */
case 69 /* Identifier */:
return checkStrictModeIdentifier(node);
case 181 /* BinaryExpression */:
if (ts.isInJavaScriptFile(node)) {
... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindWorker | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindSourceFileIfExternalModule() {
setExportContextFlag(file);
if (ts.isExternalModule(file)) {
bindSourceFileAsExternalModule();
}
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindSourceFileIfExternalModule | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindSourceFileAsExternalModule() {
bindAnonymousDeclaration(file, 512 /* ValueModule */, "\"" + ts.removeFileExtension(file.fileName) + "\"");
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindSourceFileAsExternalModule | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindExportAssignment(node) {
var boundExpression = node.kind === 227 /* ExportAssignment */ ? node.expression : node.right;
if (!container.symbol || !container.symbol.exports) {
// Export assignment in some sort of block construct
bindAnonymousDeclaration... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindExportAssignment | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindExportDeclaration(node) {
if (!container.symbol || !container.symbol.exports) {
// Export * in some sort of block construct
bindAnonymousDeclaration(node, 1073741824 /* ExportStar */, getDeclarationName(node));
}
else if (!node.exportClaus... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindExportDeclaration | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindImportClause(node) {
if (node.name) {
declareSymbolAndAddToSymbolTable(node, 8388608 /* Alias */, 8388608 /* AliasExcludes */);
}
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindImportClause | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function setCommonJsModuleIndicator(node) {
if (!file.commonJsModuleIndicator) {
file.commonJsModuleIndicator = node;
bindSourceFileAsExternalModule();
}
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | setCommonJsModuleIndicator | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindExportsPropertyAssignment(node) {
// When we create a property via 'exports.foo = bar', the 'exports.foo' property access
// expression is the declaration
setCommonJsModuleIndicator(node);
declareSymbol(file.symbol.exports, file.symbol, node.left, 4 /* Proper... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindExportsPropertyAssignment | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindModuleExportsAssignment(node) {
// 'module.exports = expr' assignment
setCommonJsModuleIndicator(node);
bindExportAssignment(node);
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindModuleExportsAssignment | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindCallExpression(node) {
// We're only inspecting call expressions to detect CommonJS modules, so we can skip
// this check if we've already seen the module indicator
if (!file.commonJsModuleIndicator && ts.isRequireCall(node)) {
setCommonJsModuleIndicator(... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindCallExpression | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindClassLikeDeclaration(node) {
if (node.kind === 214 /* ClassDeclaration */) {
bindBlockScopedDeclaration(node, 32 /* Class */, 899519 /* ClassExcludes */);
}
else {
var bindingName = node.name ? node.name.text : "__class";
b... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindClassLikeDeclaration | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindEnumDeclaration(node) {
return ts.isConst(node)
? bindBlockScopedDeclaration(node, 128 /* ConstEnum */, 899967 /* ConstEnumExcludes */)
: bindBlockScopedDeclaration(node, 256 /* RegularEnum */, 899327 /* RegularEnumExcludes */);
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindEnumDeclaration | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindVariableDeclarationOrBindingElement(node) {
if (inStrictMode) {
checkStrictModeEvalOrArguments(node, node.name);
}
if (!ts.isBindingPattern(node.name)) {
if (ts.isBlockOrCatchScoped(node)) {
bindBlockScopedVariableDecla... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindVariableDeclarationOrBindingElement | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindParameter(node) {
if (inStrictMode) {
// It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a
// strict mode FunctionLikeDeclaration or FunctionExpression(13.1)
checkStrictModeEvalOrArguments(node, node... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindParameter | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function bindPropertyOrMethodOrAccessor(node, symbolFlags, symbolExcludes) {
return ts.hasDynamicName(node)
? bindAnonymousDeclaration(node, symbolFlags, "__computed")
: declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes);
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | bindPropertyOrMethodOrAccessor | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function pushNamedLabel(name) {
initializeReachabilityStateIfNecessary();
if (ts.hasProperty(labelIndexMap, name.text)) {
return false;
}
labelIndexMap[name.text] = labelStack.push(1 /* Unintialized */) - 1;
return true;
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | pushNamedLabel | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function pushImplicitLabel() {
initializeReachabilityStateIfNecessary();
var index = labelStack.push(1 /* Unintialized */) - 1;
implicitLabels.push(index);
return index;
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | pushImplicitLabel | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function popNamedLabel(label, outerState) {
var index = labelIndexMap[label.text];
ts.Debug.assert(index !== undefined);
ts.Debug.assert(labelStack.length == index + 1);
labelIndexMap[label.text] = undefined;
setCurrentStateAtLabel(labelStack.pop(), outerState... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | popNamedLabel | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function popImplicitLabel(implicitLabelIndex, outerState) {
if (labelStack.length !== implicitLabelIndex + 1) {
ts.Debug.assert(false, "Label stack: " + labelStack.length + ", index:" + implicitLabelIndex);
}
var i = implicitLabels.pop();
if (implicitLabel... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | popImplicitLabel | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function setCurrentStateAtLabel(innerMergedState, outerState, label) {
if (innerMergedState === 1 /* Unintialized */) {
if (label && !options.allowUnusedLabels) {
file.bindDiagnostics.push(ts.createDiagnosticForNode(label, ts.Diagnostics.Unused_label));
}
... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | setCurrentStateAtLabel | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function jumpToLabel(label, outerState) {
initializeReachabilityStateIfNecessary();
var index = label ? labelIndexMap[label.text] : ts.lastOrUndefined(implicitLabels);
if (index === undefined) {
// reference to unknown label or
// break/continue used o... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | jumpToLabel | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function checkUnreachable(node) {
switch (currentReachabilityState) {
case 4 /* Unreachable */:
var reportError =
// report error on all statements except empty ones
(ts.isStatement(node) && node.kind !== 194 /* EmptyStatement */) ... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | checkUnreachable | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function shouldReportErrorOnModuleDeclaration(node) {
var instanceState = getModuleInstanceState(node);
return instanceState === 1 /* Instantiated */ || (instanceState === 2 /* ConstEnumOnly */ && options.preserveConstEnums);
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | shouldReportErrorOnModuleDeclaration | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function initializeReachabilityStateIfNecessary() {
if (labelIndexMap) {
return;
}
currentReachabilityState = 2 /* Reachable */;
labelIndexMap = {};
labelStack = [];
implicitLabels = [];
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | initializeReachabilityStateIfNecessary | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getNodeId(node) {
if (!node.id)
node.id = nextNodeId++;
return node.id;
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | getNodeId | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getSymbolId(symbol) {
if (!symbol.id) {
symbol.id = nextSymbolId++;
}
return symbol.id;
} | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | getSymbolId | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function createTypeChecker(host, produceDiagnostics) {
// Cancellation that controls whether or not we can cancel in the middle of type checking.
// In general cancelling is *not* safe for the type checker. We might be in the middle of
// computing something, and we will leave our internals in ... | Returns true if node and its subnodes were successfully traversed.
Returning false means that node was not examined and caller needs to dive into the node himself. | createTypeChecker | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function appendSymbolNameOnly(symbol, writer) {
writer.writeSymbol(getNameOfSymbol(symbol), symbol);
} | Writes only the name of the symbol out to the writer. Uses the original source text
for the name of the symbol if it is available to match how the user inputted the name. | appendSymbolNameOnly | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags, typeFlags) {
var parentSymbol;
function appendParentTypeArgumentsAndSymbolName(symbol) {
if (parentSymbol) {
// Write type arguments of instantiated class/interfa... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | buildSymbolDisplay | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function appendParentTypeArgumentsAndSymbolName(symbol) {
if (parentSymbol) {
// Write type arguments of instantiated class/interface here
if (flags & 1 /* WriteTypeParametersOrArguments */) {
if (symbol.flags & 16777216 /* ... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | appendParentTypeArgumentsAndSymbolName | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function walkSymbol(symbol, meaning) {
if (symbol) {
var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, !!(flags & 2 /* UseOnlyExternalAliasing */));
if (!accessibleSymbolChain ||
nee... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | walkSymbol | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function buildTypeDisplay(type, writer, enclosingDeclaration, globalFlags, symbolStack) {
var globalFlagsToPass = globalFlags & 16 /* WriteOwnNameForAnyLike */;
var inObjectTypeLiteral = false;
return writeType(type, globalFlags);
function writeType(type, ... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | buildTypeDisplay | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function writeType(type, flags) {
// Write undefined/null type as any
if (type.flags & 16777343 /* Intrinsic */) {
// Special handling for unknown / resolving types, they should show up as any and not unknown or __resolving
writer.w... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | writeType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function writeTypeList(types, delimiter) {
for (var i = 0; i < types.length; i++) {
if (i > 0) {
if (delimiter !== 24 /* CommaToken */) {
writeSpace(writer);
}
... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | writeTypeList | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function writeSymbolTypeReference(symbol, typeArguments, pos, end, flags) {
// Unnamed function expressions and arrow functions have reserved names that we don't want to display
if (symbol.flags & 32 /* Class */ || !isReservedMemberName(symbol.name)) {
bui... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | writeSymbolTypeReference | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function writeTypeReference(type, flags) {
var typeArguments = type.typeArguments || emptyArray;
if (type.target === globalArrayType && !(flags & 1 /* WriteArrayAsGenericType */)) {
writeType(typeArguments[0], 64 /* InElementType */);
... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | writeTypeReference | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function writeTupleType(type) {
writePunctuation(writer, 19 /* OpenBracketToken */);
writeTypeList(type.elementTypes, 24 /* CommaToken */);
writePunctuation(writer, 20 /* CloseBracketToken */);
} | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | writeTupleType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function writeUnionOrIntersectionType(type, flags) {
if (flags & 64 /* InElementType */) {
writePunctuation(writer, 17 /* OpenParenToken */);
}
writeTypeList(type.types, type.flags & 16384 /* Union */ ? 47 /* BarToken */ : 46 /* Ampersa... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | writeUnionOrIntersectionType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function writeAnonymousType(type, flags) {
var symbol = type.symbol;
if (symbol) {
// Always use 'typeof T' for type of class, enum, and module objects
if (symbol.flags & (32 /* Class */ | 384 /* Enum */ | 512 /* ValueModule */)) {
... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | writeAnonymousType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function shouldWriteTypeOfFunctionSymbol() {
var isStaticMethodSymbol = !!(symbol.flags & 8192 /* Method */ &&
ts.forEach(symbol.declarations, function (declaration) { return declaration.flags & 64 /* Static */; }));
var isNonLocalFunctionSymbo... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | shouldWriteTypeOfFunctionSymbol | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function writeTypeofSymbol(type, typeFormatFlags) {
writeKeyword(writer, 101 /* TypeOfKeyword */);
writeSpace(writer);
buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, 107455 /* Value */, 0 /* None */, typeFormatFlags);
} | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | writeTypeofSymbol | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getIndexerParameterName(type, indexKind, fallbackName) {
var declaration = getIndexDeclarationOfSymbol(type.symbol, indexKind);
if (!declaration) {
// declaration might not be found if indexer was added from the contextual type.
... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | getIndexerParameterName | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function writeLiteralType(type, flags) {
var resolved = resolveStructuredTypeMembers(type);
if (!resolved.properties.length && !resolved.stringIndexType && !resolved.numberIndexType) {
if (!resolved.callSignatures.length && !resolved.constructSignatures.le... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | writeLiteralType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function buildTypeParameterDisplayFromSymbol(symbol, writer, enclosingDeclaraiton, flags) {
var targetSymbol = getTargetSymbol(symbol);
if (targetSymbol.flags & 32 /* Class */ || targetSymbol.flags & 64 /* Interface */ || targetSymbol.flags & 524288 /* TypeAlias */) {
... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | buildTypeParameterDisplayFromSymbol | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function buildTypeParameterDisplay(tp, writer, enclosingDeclaration, flags, symbolStack) {
appendSymbolNameOnly(tp.symbol, writer);
var constraint = getConstraintOfTypeParameter(tp);
if (constraint) {
writeSpace(writer);
writeKeywor... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | buildTypeParameterDisplay | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function buildParameterDisplay(p, writer, enclosingDeclaration, flags, symbolStack) {
var parameterNode = p.valueDeclaration;
if (ts.isRestParameter(parameterNode)) {
writePunctuation(writer, 22 /* DotDotDotToken */);
}
appendSymbolName... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | buildParameterDisplay | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function buildDisplayForTypeParametersAndDelimiters(typeParameters, writer, enclosingDeclaration, flags, symbolStack) {
if (typeParameters && typeParameters.length) {
writePunctuation(writer, 25 /* LessThanToken */);
for (var i = 0; i < typeParameters.length; i++)... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | buildDisplayForTypeParametersAndDelimiters | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function buildDisplayForTypeArgumentsAndDelimiters(typeParameters, mapper, writer, enclosingDeclaration, flags, symbolStack) {
if (typeParameters && typeParameters.length) {
writePunctuation(writer, 25 /* LessThanToken */);
for (var i = 0; i < typeParameters.lengt... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | buildDisplayForTypeArgumentsAndDelimiters | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function buildDisplayForParametersAndDelimiters(parameters, writer, enclosingDeclaration, flags, symbolStack) {
writePunctuation(writer, 17 /* OpenParenToken */);
for (var i = 0; i < parameters.length; i++) {
if (i > 0) {
writePunctuation(write... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | buildDisplayForParametersAndDelimiters | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function buildReturnTypeDisplay(signature, writer, enclosingDeclaration, flags, symbolStack) {
if (flags & 8 /* WriteArrowStyleSignature */) {
writeSpace(writer);
writePunctuation(writer, 34 /* EqualsGreaterThanToken */);
}
else {
... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | buildReturnTypeDisplay | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function buildSignatureDisplay(signature, writer, enclosingDeclaration, flags, symbolStack) {
if (signature.target && (flags & 32 /* WriteTypeArgumentsOfSignature */)) {
// Instantiated signature, write type arguments instead
// This is achieved by passing in the ... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | buildSignatureDisplay | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isDeclarationVisible(node) {
function getContainingExternalModule(node) {
for (; node; node = node.parent) {
if (node.kind === 218 /* ModuleDeclaration */) {
if (node.name.kind === 9 /* StringLiteral */) {
retur... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | isDeclarationVisible | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getContainingExternalModule(node) {
for (; node; node = node.parent) {
if (node.kind === 218 /* ModuleDeclaration */) {
if (node.name.kind === 9 /* StringLiteral */) {
return node;
}
... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | getContainingExternalModule | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isUsedInExportAssignment(node) {
// Get source File and see if it is external module and has export assigned symbol
var externalModule = getContainingExternalModule(node);
var exportAssignmentSymbol;
var resolvedExportSymbol;
if (e... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | isUsedInExportAssignment | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function determineIfDeclarationIsVisible() {
switch (node.kind) {
case 163 /* BindingElement */:
return isDeclarationVisible(node.parent.parent);
case 211 /* VariableDeclaration */:
if (ts.isBindingPattern(node.name)... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | determineIfDeclarationIsVisible | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function collectLinkedAliases(node) {
var exportSymbol;
if (node.parent && node.parent.kind === 227 /* ExportAssignment */) {
exportSymbol = resolveName(node.parent, node.text, 107455 /* Value */ | 793056 /* Type */ | 1536 /* Namespace */ | 8388608 /* Alias */, ts.Diagnostics.Can... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | collectLinkedAliases | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function buildVisibleNodeList(declarations) {
ts.forEach(declarations, function (declaration) {
getNodeLinks(declaration).isVisible = true;
var resultNode = getAnyImportSyntax(declaration) || declaration;
if (!ts.contains(result, resultNode)) {... | Enclosing declaration is optional when we don't want to get qualified name in the enclosing declaration scope
Meaning needs to be specified if the enclosing declaration is given | buildVisibleNodeList | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function pushTypeResolution(target, propertyName) {
var resolutionCycleStartIndex = findResolutionCycleStartIndex(target, propertyName);
if (resolutionCycleStartIndex >= 0) {
// A cycle was found
var length_2 = resolutionTargets.length;
for (var i ... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | pushTypeResolution | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function findResolutionCycleStartIndex(target, propertyName) {
for (var i = resolutionTargets.length - 1; i >= 0; i--) {
if (hasType(resolutionTargets[i], resolutionPropertyNames[i])) {
return -1;
}
if (resolutionTargets[i] === target && re... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | findResolutionCycleStartIndex | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function hasType(target, propertyName) {
if (propertyName === 0 /* Type */) {
return getSymbolLinks(target).type;
}
if (propertyName === 2 /* DeclaredType */) {
return getSymbolLinks(target).declaredType;
}
if (propertyName === ... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | hasType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function popTypeResolution() {
resolutionTargets.pop();
resolutionPropertyNames.pop();
return resolutionResults.pop();
} | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | popTypeResolution | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getDeclarationContainer(node) {
node = ts.getRootDeclaration(node);
// Parent chain:
// VaribleDeclaration -> VariableDeclarationList -> VariableStatement -> 'Declaration Container'
return node.kind === 211 /* VariableDeclaration */ ? node.parent.parent.parent : ... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getDeclarationContainer | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypeOfPrototypeProperty(prototype) {
// TypeScript 1.0 spec (April 2014): 8.4
// Every class automatically contains a static property member named 'prototype',
// the type of which is an instantiation of the class type with type Any supplied as a type argument for each ty... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTypeOfPrototypeProperty | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isTypeAny(type) {
return type && (type.flags & 1 /* Any */) !== 0;
} | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | isTypeAny | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTextOfPropertyName(name) {
switch (name.kind) {
case 69 /* Identifier */:
return name.text;
case 9 /* StringLiteral */:
case 8 /* NumericLiteral */:
return name.text;
case 136 /* ComputedPrope... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTextOfPropertyName | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isComputedNonLiteralName(name) {
return name.kind === 136 /* ComputedPropertyName */ && !ts.isStringOrNumericLiteral(name.expression.kind);
} | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | isComputedNonLiteralName | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypeForBindingElement(declaration) {
var pattern = declaration.parent;
var parentType = getTypeForBindingElementParent(pattern.parent);
// If parent has the unknown (error) type, then so does this binding element
if (parentType === unknownType) {
... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTypeForBindingElement | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypeFromObjectBindingPattern(pattern, includePatternInType) {
var members = {};
var hasComputedProperties = false;
ts.forEach(pattern.elements, function (e) {
var name = e.propertyName || e.name;
if (isComputedNonLiteralName(name)) {
... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTypeFromObjectBindingPattern | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypeFromArrayBindingPattern(pattern, includePatternInType) {
var elements = pattern.elements;
if (elements.length === 0 || elements[elements.length - 1].dotDotDotToken) {
return languageVersion >= 2 /* ES6 */ ? createIterableType(anyType) : anyArrayType;
}... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTypeFromArrayBindingPattern | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypeOfVariableOrParameterOrProperty(symbol) {
var links = getSymbolLinks(symbol);
if (!links.type) {
// Handle prototype property
if (symbol.flags & 134217728 /* Prototype */) {
return links.type = getTypeOfPrototypeProperty(symbol)... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTypeOfVariableOrParameterOrProperty | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getAnnotatedAccessorType(accessor) {
if (accessor) {
if (accessor.kind === 145 /* GetAccessor */) {
return accessor.type && getTypeFromTypeNode(accessor.type);
}
else {
var setterTypeAnnotation = ts.getSetAccess... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getAnnotatedAccessorType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypeOfAccessors(symbol) {
var links = getSymbolLinks(symbol);
if (!links.type) {
if (!pushTypeResolution(symbol, 0 /* Type */)) {
return unknownType;
}
var getter = ts.getDeclarationOfKind(symbol, 145 /* GetAccessor ... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTypeOfAccessors | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypeOfFuncClassEnumModule(symbol) {
var links = getSymbolLinks(symbol);
if (!links.type) {
links.type = createObjectType(65536 /* Anonymous */, symbol);
}
return links.type;
} | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTypeOfFuncClassEnumModule | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypeOfEnumMember(symbol) {
var links = getSymbolLinks(symbol);
if (!links.type) {
links.type = getDeclaredTypeOfEnum(getParentOfSymbol(symbol));
}
return links.type;
} | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTypeOfEnumMember | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypeOfAlias(symbol) {
var links = getSymbolLinks(symbol);
if (!links.type) {
var targetSymbol = resolveAlias(symbol);
// It only makes sense to get the type of a value symbol. If the result of resolving
// the alias is not a value, then... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTypeOfAlias | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypeOfInstantiatedSymbol(symbol) {
var links = getSymbolLinks(symbol);
if (!links.type) {
links.type = instantiateType(getTypeOfSymbol(links.target), links.mapper);
}
return links.type;
} | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTypeOfInstantiatedSymbol | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypeOfSymbol(symbol) {
if (symbol.flags & 16777216 /* Instantiated */) {
return getTypeOfInstantiatedSymbol(symbol);
}
if (symbol.flags & (3 /* Variable */ | 4 /* Property */)) {
return getTypeOfVariableOrParameterOrProperty(symbol);
... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTypeOfSymbol | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTargetType(type) {
return type.flags & 4096 /* Reference */ ? type.target : type;
} | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTargetType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function hasBaseType(type, checkBase) {
return check(type);
function check(type) {
var target = getTargetType(type);
return target === checkBase || ts.forEach(getBaseTypes(target), check);
}
} | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | hasBaseType | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function check(type) {
var target = getTargetType(type);
return target === checkBase || ts.forEach(getBaseTypes(target), check);
} | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | check | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function appendTypeParameters(typeParameters, declarations) {
for (var _i = 0, declarations_2 = declarations; _i < declarations_2.length; _i++) {
var declaration = declarations_2[_i];
var tp = getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration));
if (!... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | appendTypeParameters | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function appendOuterTypeParameters(typeParameters, node) {
while (true) {
node = node.parent;
if (!node) {
return typeParameters;
}
if (node.kind === 214 /* ClassDeclaration */ || node.kind === 186 /* ClassExpression */ ||
... | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | appendOuterTypeParameters | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getOuterTypeParametersOfClassOrInterface(symbol) {
var declaration = symbol.flags & 32 /* Class */ ? symbol.valueDeclaration : ts.getDeclarationOfKind(symbol, 215 /* InterfaceDeclaration */);
return appendOuterTypeParameters(undefined, declaration);
} | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getOuterTypeParametersOfClassOrInterface | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function getTypeParametersOfClassOrInterface(symbol) {
return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol));
} | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | getTypeParametersOfClassOrInterface | javascript | amol-/dukpy | dukpy/jsmodules/typescriptServices.js | https://github.com/amol-/dukpy/blob/master/dukpy/jsmodules/typescriptServices.js | MIT |
function isConstructorType(type) {
return type.flags & 80896 /* ObjectType */ && getSignaturesOfType(type, 1 /* Construct */).length > 0;
} | Push an entry on the type resolution stack. If an entry with the given target and the given property name
is already on the stack, and no entries in between already have a type, then a circularity has occurred.
In this case, the result values of the existing entry and all entries pushed after it are changed to false,
a... | isConstructorType | 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.