_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 27
233k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q1400
|
fileChanged
|
train
|
function fileChanged(status, filepath) {
// If file was deleted and then re-added, consider it changed.
if (changedFiles[filepath] === 'deleted' && status === 'added') {
status = 'changed';
}
// Keep track of changed status for later.
changedFiles[filepath] = status;
// Emit watch events if anyone is listening
if (grunt.event.listeners('watch').length > 0) {
var matchingTargets = [];
targets.forEach(function(target) {
if (grunt.file.match(target.files, filepath).length > 0) {
matchingTargets.push(target.name);
|
javascript
|
{
"resource": ""
}
|
q1401
|
watchFile
|
train
|
function watchFile(filepath) {
if (!watchedFiles[filepath]) {
// add a new file to watched files
var statStructure = null;
try {
statStructure = fs.statSync(filepath);
} catch (e) { // StatSync can throw an error if the
|
javascript
|
{
"resource": ""
}
|
q1402
|
makeArray
|
train
|
function makeArray( obj ) {
var ary = [];
if ( isArray( obj ) ) {
// use object if already an array
ary = obj;
} else if ( typeof obj.length === 'number'
|
javascript
|
{
"resource": ""
}
|
q1403
|
train
|
function(context, pkg, source) {
source = source || "{}";
var packageJSON = JSON.parse(source);
|
javascript
|
{
"resource": ""
}
|
|
q1404
|
train
|
function(context, pkg){
var deps = crawl.getDependencyMap(context.loader, pkg, true);
var pluginsPromise = crawl.loadPlugins(context, pkg, true, deps, true);
var stealPromise =
|
javascript
|
{
"resource": ""
}
|
|
q1405
|
train
|
function(context, pkg, isRoot) {
var deps = crawl.getDependencies(context.loader, pkg, isRoot);
return Promise.all(utils.filter(utils.map(deps, function(childPkg){
return crawl.fetchDep(context, pkg, childPkg, isRoot);
}), truthy)).then(function(packages){
// at this point all dependencies of pkg have been loaded, it's ok to get their children
return Promise.all(utils.map(packages, function(childPkg){
// Also load 'steal'
|
javascript
|
{
"resource": ""
}
|
|
q1406
|
train
|
function(context, parentPkg, childPkg, isRoot){
var pkg = parentPkg;
var isFlat = context.isFlatFileStructure;
// if a peer dependency, and not isRoot
if(childPkg._isPeerDependency && !isRoot ) {
// check one node_module level higher
childPkg.origFileUrl = nodeModuleAddress(pkg.fileUrl)+"/"+childPkg.name+"/package.json";
} else if(isRoot) {
childPkg.origFileUrl = utils.path.depPackage(pkg.fileUrl, childPkg.name);
} else {
// npm 2
childPkg.origFileUrl = childPkg.nestedFileUrl =
utils.path.depPackage(pkg.fileUrl, childPkg.name);
if(isFlat) {
// npm 3
childPkg.origFileUrl = crawl.parentMostAddress(context,
childPkg);
}
}
// check if childPkg matches a parent's version ... if
|
javascript
|
{
"resource": ""
}
|
|
q1407
|
train
|
function(context, pkg, isRoot, deps){
var stealPkg = utils.filter(deps, function(dep){
return dep && dep.name === "steal";
})[0];
if(stealPkg) {
return crawl.fetchDep(context, pkg, stealPkg, isRoot)
.then(function(childPkg){
|
javascript
|
{
"resource": ""
}
|
|
q1408
|
train
|
function(loader, packageJSON, isRoot){
var deps = crawl.getDependencyMap(loader, packageJSON, isRoot);
var dependencies = [];
|
javascript
|
{
"resource": ""
}
|
|
q1409
|
train
|
function(loader, packageJSON, isRoot){
var config = utils.pkg.config(packageJSON);
var hasConfig = !!config;
// convert npmIgnore
var npmIgnore = hasConfig && config.npmIgnore;
function convertToMap(arr) {
var npmMap = {};
for(var i = 0; i < arr.length; i++) {
npmMap[arr[i]] = true;
}
return npmMap;
}
if(npmIgnore && typeof npmIgnore.length === 'number') {
npmIgnore = config.npmIgnore = convertToMap(npmIgnore);
}
// convert npmDependencies
var npmDependencies = hasConfig && config.npmDependencies;
if(npmDependencies && typeof npmDependencies.length === "number") {
config.npmDependencies = convertToMap(npmDependencies);
}
|
javascript
|
{
"resource": ""
}
|
|
q1410
|
train
|
function(context, childPkg){
var curAddress = childPkg.origFileUrl;
var parentAddress = utils.path.parentNodeModuleAddress(childPkg.origFileUrl);
while(parentAddress) {
var packageAddress = parentAddress+"/"+childPkg.name+"/package.json";
var parentPkg = context.paths[packageAddress];
if(parentPkg && SemVer.valid(parentPkg.version)) {
if(SemVer.satisfies(parentPkg.version, childPkg.version)) {
|
javascript
|
{
"resource": ""
}
|
|
q1411
|
train
|
function(pkg){
var pkg = pkg || this.getPackage();
var requestedVersion = this.requestedVersion;
return SemVer.validRange(requestedVersion) &&
|
javascript
|
{
"resource": ""
}
|
|
q1412
|
train
|
function(){
// If a task is currently loading this fileUrl,
// wait for it to complete
var loadingTask = this.context.loadingPaths[this.fileUrl];
if (!loadingTask) return;
var task = this;
return loadingTask.promise.then(function() {
task._fetchedPackage = loadingTask.getPackage();
var firstTaskFailed = loadingTask.hadErrorLoading();
var currentTaskIsCompatible = task.isCompatibleVersion();
var firstTaskIsNotCompatible = !loadingTask.isCompatibleVersion();
// Do not flag the current task as failed if:
//
// - Current task fetches a version in rage and
// - First task had no error loading at all or
// - First task fetched an incompatible version
//
// otherwise, assume current task will fail for the same
|
javascript
|
{
"resource": ""
}
|
|
q1413
|
train
|
function(){
// If it is already loaded check to see if it's semver compatible
// and if so use it. Otherwise reject.
var loadedPkg =
|
javascript
|
{
"resource": ""
}
|
|
q1414
|
train
|
function(){
var pkg = utils.extend({}, this.orig);
var isFlat = this.context.isFlatFileStructure;
var fileUrl = this.pkg.fileUrl;
var context = this.context;
if(isFlat && !pkg.__crawledNestedPosition) {
pkg.__crawledNestedPosition = true;
pkg.nextFileUrl = pkg.nestedFileUrl;
}
else {
// make sure we aren't loading something we've already loaded
var parentAddress = utils.path.parentNodeModuleAddress(fileUrl);
if(!parentAddress) {
|
javascript
|
{
"resource": ""
}
|
|
q1415
|
npmLoad
|
train
|
function npmLoad(context, pkg){
var task = new FetchTask(context, pkg);
return task.load().then(function(){
if(task.failed) {
// Recurse. Calling task.next gives us a new pkg object
// with the fileUrl
|
javascript
|
{
"resource": ""
}
|
q1416
|
transformToString
|
train
|
function transformToString(xform) {
var m = xform.matrix,
text = '';
switch(xform.type) {
case 1: // MATRIX
text = 'matrix(' + [m.a, m.b, m.c, m.d, m.e, m.f].join(',') + ')';
break;
case 2: // TRANSLATE
text = 'translate(' + m.e + ',' + m.f + ')';
break;
case 3: // SCALE
|
javascript
|
{
"resource": ""
}
|
q1417
|
basicIdentityIsSet
|
train
|
function basicIdentityIsSet(){
return _.has(user, 'identities') && _.has(user.identities,
|
javascript
|
{
"resource": ""
}
|
q1418
|
exists
|
train
|
function exists(cmd) {
return run(`which ${cmd}`).then(stdout => {
if (stdout.trim().length === 0) {
// maybe an empty command was supplied?
// are we running on Windows??
return Promise.reject(new Error("No output"));
|
javascript
|
{
"resource": ""
}
|
q1419
|
Fireproof
|
train
|
function Fireproof(firebaseRef, promise) {
if (!Fireproof.Promise) {
try {
Fireproof.Promise = Promise;
} catch(e) {
throw new Error('You must supply a Promise library to Fireproof!');
}
} else if (typeof Fireproof.Promise !== 'function') {
throw new Error('The supplied value of Fireproof.Promise is not a constructor (got ' +
Fireproof.Promise + ')');
}
|
javascript
|
{
"resource": ""
}
|
q1420
|
train
|
function(win, elems) {
var mode = svgCanvas.getMode();
if (mode === 'select') {
setSelectMode();
}
var is_node = (mode == "pathedit");
// if elems[1] is present, then we have more than one element
selectedElement = (elems.length === 1 || elems[1] == null ? elems[0] : null);
multiselected = (elems.length >= 2 && elems[1] != null);
if (selectedElement != null) {
// unless we're already in always set the mode of the editor to select because
// upon creation of a text element the editor is switched into
// select mode and this event fires - we need our UI to be in sync
if (!is_node) {
|
javascript
|
{
"resource": ""
}
|
|
q1421
|
train
|
function(win, elems) {
var mode = svgCanvas.getMode();
var elem = elems[0];
if (!elem) {
return;
}
multiselected = (elems.length >= 2 && elems[1] != null);
// Only updating fields for single elements for now
if (!multiselected) {
switch (mode) {
case 'rotate':
var ang = svgCanvas.getRotationAngle(elem);
$('#angle').val(ang);
|
javascript
|
{
"resource": ""
}
|
|
q1422
|
train
|
function(win, elems) {
var i,
mode = svgCanvas.getMode();
if (mode === 'select') {
setSelectMode();
}
for (i = 0; i < elems.length; ++i) {
var elem = elems[i];
// if the element changed was the svg, then it could be a resolution change
if (elem && elem.tagName === 'svg') {
populateLayers();
updateCanvas();
}
// Update selectedElement if element is no longer part of the image.
// This occurs for the text elements in Firefox
else if (elem && selectedElement && selectedElement.parentNode == null) {
// || elem && elem.tagName == "path" && !multiselected) { // This was added in r1430, but not sure why
selectedElement = elem;
}
}
Editor.showSaveWarning = true;
// we update the contextual panel with potentially new
|
javascript
|
{
"resource": ""
}
|
|
q1423
|
train
|
function(event) {
var options = opts;
//find the currently selected tool if comes from keystroke
if (event.type === 'keydown') {
var flyoutIsSelected = $(options.parent + '_show').hasClass('tool_button_current');
var currentOperation = $(options.parent + '_show').attr('data-curopt');
$.each(holders[opts.parent], function(i, tool) {
if (tool.sel == currentOperation) {
if (!event.shiftKey || !flyoutIsSelected) {
options = tool;
} else {
options = holders[opts.parent][i+1] || holders[opts.parent][0];
}
}
});
}
if ($(this).hasClass('disabled')) {return false;}
if (toolButtonClick(show_sel)) {
options.fn();
}
var icon;
if (options.icon) {
|
javascript
|
{
"resource": ""
}
|
|
q1424
|
train
|
function(close) {
var w = $('#sidepanels').width();
var deltaX = (w > 2 || close ? 2
|
javascript
|
{
"resource": ""
}
|
|
q1425
|
train
|
function(width, height) {
var newImage = svgCanvas.addSvgElementFromJson({
element: 'image',
attr: {
x: 0,
y: 0,
width: width,
height: height,
id: svgCanvas.getNextId(),
style: 'pointer-events:inherit'
}
});
|
javascript
|
{
"resource": ""
}
|
|
q1426
|
train
|
function(data, hashId, key) {
if (hashId == -1) {
// record key
data.inputChar = key;
data.lastEvent = "input";
} else if (data.inputChar && data.$lastHash == hashId && data.$lastKey == key) {
// check for repeated keypress
if (data.lastEvent == "input") {
data.lastEvent = "input1";
} else if (data.lastEvent == "input1") {
|
javascript
|
{
"resource": ""
}
|
|
q1427
|
convertPropertyNames
|
train
|
function convertPropertyNames (context, pkg, map , root, waiting) {
if(!map) {
return map;
}
var clone = {}, value;
for(var property in map ) {
value = convertName(context, pkg, map, root, property, waiting);
if(typeof value === 'string') {
clone[value] = map[property];
}
// do root paths b/c we don't know if they are going to be included with the package name or
|
javascript
|
{
"resource": ""
}
|
q1428
|
convertPropertyNamesAndValues
|
train
|
function convertPropertyNamesAndValues (context, pkg, map, root, waiting) {
if(!map) {
return map;
}
var clone = {}, val, name;
for(var property in map ) {
val = map[property];
name = convertName(context, pkg, map, root, property, waiting);
val = typeof val === "object"
?
|
javascript
|
{
"resource": ""
}
|
q1429
|
convertBrowser
|
train
|
function convertBrowser(pkg, browser) {
var type = typeof browser;
if(type === "string" || type === "undefined") {
return browser;
}
var map = {};
for(var fromName in browser) {
|
javascript
|
{
"resource": ""
}
|
q1430
|
convertForPackage
|
train
|
function convertForPackage(context, pkg) {
var name = pkg.name;
var version = pkg.version;
var conv = context.deferredConversions;
var pkgConv = conv[name];
var depPkg, fns, keys = 0;
if(pkgConv) {
for(var range in
|
javascript
|
{
"resource": ""
}
|
q1431
|
rebuildInput
|
train
|
function rebuildInput(form) {
form.empty();
var inp = $('<input type="file" name="svg_file">').appendTo(form);
function submit() {
// This submits the form, which returns the file data using svgEditor.processFile()
form.submit();
rebuildInput(form);
$.process_cancel("Uploading...", function() {
|
javascript
|
{
"resource": ""
}
|
q1432
|
max
|
train
|
function max(compare, iterable, dflt = undefined) {
let iterator = (0, _iter.iter)(iterable);
let first = iterator.next();
if (first.done) return dflt;
let largest = first.value;
for (let candidate of iterator)
|
javascript
|
{
"resource": ""
}
|
q1433
|
train
|
function() {
self.value += stepValue;
self.setValue(self.value);
self.triggerScrollEvent(self.value);
|
javascript
|
{
"resource": ""
}
|
|
q1434
|
SelectList
|
train
|
function SelectList(options) {
this.options = $.extend({
holder: null,
maxVisibleItems: 10,
selectOnClick: true,
useHoverClass: false,
useCustomScroll: false,
handleResize: true,
multipleSelectWithoutKey: false,
alwaysPreventMouseWheel: false,
indexAttribute: 'data-index',
cloneClassPrefix: 'jcf-option-',
containerStructure: '<span class="jcf-list"><span class="jcf-list-content"></span></span>',
containerSelector: '.jcf-list-content',
|
javascript
|
{
"resource": ""
}
|
q1435
|
isSerializedHelper
|
train
|
function isSerializedHelper(obj){
if (typeReflections.isPrimitive(obj)) {
return true;
}
if(hasUpdateSymbol(obj)) {
return false;
}
return
|
javascript
|
{
"resource": ""
}
|
q1436
|
train
|
function(obj){
var hasOwnKey = obj[canSymbol.for("can.hasOwnKey")];
if(hasOwnKey) {
return hasOwnKey.bind(obj);
} else {
var map =
|
javascript
|
{
"resource": ""
}
|
|
q1437
|
addPatch
|
train
|
function addPatch(patches, patch) {
var lastPatch = patches[patches.length -1];
if(lastPatch) {
// same number of deletes and counts as the index is back
if(lastPatch.deleteCount === lastPatch.insert.length && (patch.index - lastPatch.index === lastPatch.deleteCount) )
|
javascript
|
{
"resource": ""
}
|
q1438
|
setComparator
|
train
|
function setComparator() {
// If the first three letters are "asc", sort in ascending order
// and remove the prefix.
if (by.substring(0,3) == 'asc') {
var i = by.substring(3);
comp = function(a, b) { return a[i] - b[i]; };
} else {
// Otherwise sort in descending order.
comp = function(a, b)
|
javascript
|
{
"resource": ""
}
|
q1439
|
initComparator
|
train
|
function initComparator() {
by = 'rating'; // Default to sort by rating.
// If the sortBy cookie is set, use that instead.
if (document.cookie.length > 0) {
var start = document.cookie.indexOf('sortBy=');
if (start != -1) {
start = start + 7;
var end = document.cookie.indexOf(";",
|
javascript
|
{
"resource": ""
}
|
q1440
|
show
|
train
|
function show(id) {
$('#ao' + id).hide();
$('#ah' + id).show();
var context = $.extend({id: id}, opts);
var popup = $(renderTemplate(popupTemplate, context)).hide();
popup.find('textarea[name="proposal"]').hide();
popup.find('a.by' + by).addClass('sel');
var form = popup.find('#cf' + id);
|
javascript
|
{
"resource": ""
}
|
q1441
|
hide
|
train
|
function hide(id) {
$('#ah' + id).hide();
$('#ao' + id).show();
var div = $('#sc' +
|
javascript
|
{
"resource": ""
}
|
q1442
|
getComments
|
train
|
function getComments(id) {
$.ajax({
type: 'GET',
url: opts.getCommentsURL,
data: {node: id},
success: function(data, textStatus, request) {
var ul = $('#cl' + id);
var speed = 100;
$('#cf' + id)
.find('textarea[name="proposal"]')
.data('source', data.source);
if (data.comments.length === 0) {
ul.html('<li>No comments yet.</li>');
ul.data('empty', true);
} else {
// If there are comments, sort them and put them in the list.
var comments = sortComments(data.comments);
speed = data.comments.length * 100;
|
javascript
|
{
"resource": ""
}
|
q1443
|
addComment
|
train
|
function addComment(form) {
var node_id = form.find('input[name="node"]').val();
var parent_id = form.find('input[name="parent"]').val();
var text = form.find('textarea[name="comment"]').val();
var proposal = form.find('textarea[name="proposal"]').val();
if (text == '') {
showError('Please enter a comment.');
return;
}
// Disable the form that is being submitted.
form.find('textarea,input').attr('disabled', 'disabled');
// Send the comment to the server.
$.ajax({
type: "POST",
url: opts.addCommentURL,
dataType: 'json',
data: {
node: node_id,
parent: parent_id,
text: text,
proposal: proposal
},
success: function(data, textStatus, error) {
// Reset the form.
if (node_id) {
hideProposeChange(node_id);
}
form.find('textarea')
.val('')
.add(form.find('input'))
.removeAttr('disabled');
var ul = $('#cl' + (node_id || parent_id));
if (ul.data('empty')) {
$(ul).empty();
|
javascript
|
{
"resource": ""
}
|
q1444
|
appendComments
|
train
|
function appendComments(comments, ul) {
$.each(comments, function() {
var div = createCommentDiv(this);
ul.append($(document.createElement('li')).html(div));
appendComments(this.children, div.find('ul.comment-children'));
// To avoid stagnating
|
javascript
|
{
"resource": ""
}
|
q1445
|
insertComment
|
train
|
function insertComment(comment) {
var div = createCommentDiv(comment);
// To avoid stagnating data, don't store the comments children in data.
comment.children = null;
div.data('comment', comment);
var ul = $('#cl' + (comment.node || comment.parent));
var siblings = getChildren(ul);
var li = $(document.createElement('li'));
li.hide();
// Determine where in the parents children list to insert this comment.
for(i=0; i < siblings.length; i++) {
if (comp(comment, siblings[i]) <= 0) {
$('#cd' + siblings[i].id)
.parent()
|
javascript
|
{
"resource": ""
}
|
q1446
|
handleReSort
|
train
|
function handleReSort(link) {
var classes = link.attr('class').split(/\s+/);
for (var i=0; i<classes.length; i++) {
if (classes[i] != 'sort-option') {
by = classes[i].substring(2);
}
}
setComparator();
// Save/update the sortBy cookie.
var expiration = new Date();
expiration.setDate(expiration.getDate() + 365);
document.cookie= 'sortBy=' + escape(by) +
|
javascript
|
{
"resource": ""
}
|
q1447
|
handleVote
|
train
|
function handleVote(link) {
if (!opts.voting) {
showError("You'll need to login to vote.");
return;
}
var id = link.attr('id');
if (!id) {
// Didn't click on one of the voting arrows.
return;
}
// If it is an unvote, the new vote value is 0,
// Otherwise it's 1 for an upvote, or -1 for a downvote.
var value = 0;
if (id.charAt(1) != 'u') {
value = id.charAt(0) == 'u' ? 1 : -1;
}
// The data to be sent to the server.
var d = {
comment_id: id.substring(2),
value: value
};
// Swap the vote and unvote links.
link.hide();
$('#' + id.charAt(0) + (id.charAt(1) == 'u' ? 'v' : 'u') + d.comment_id)
.show();
|
javascript
|
{
"resource": ""
}
|
q1448
|
openReply
|
train
|
function openReply(id) {
// Swap out the reply link for the hide link
$('#rl' + id).hide();
$('#cr' + id).show();
// Add the reply li to the children ul.
var div = $(renderTemplate(replyTemplate, {id: id})).hide();
$('#cl' + id)
.prepend(div)
// Setup the submit handler for the reply form.
.find('#rf' + id)
.submit(function(event) {
|
javascript
|
{
"resource": ""
}
|
q1449
|
sortComments
|
train
|
function sortComments(comments) {
comments.sort(comp);
$.each(comments, function() {
this.children
|
javascript
|
{
"resource": ""
}
|
q1450
|
getChildren
|
train
|
function getChildren(ul, recursive) {
var children = [];
ul.children().children("[id^='cd']")
.each(function() {
var comment = $(this).data('comment');
if (recursive)
|
javascript
|
{
"resource": ""
}
|
q1451
|
createCommentDiv
|
train
|
function createCommentDiv(comment) {
if (!comment.displayed && !opts.moderator) {
return $('<div class="moderate">Thank you! Your comment will show up '
+ 'once it is has been approved by a moderator.</div>');
}
// Prettify the comment rating.
comment.pretty_rating = comment.rating + ' point' +
(comment.rating == 1 ? '' : 's');
// Make a class (for displaying not yet moderated comments differently)
comment.css_class = comment.displayed ? '' : ' moderate';
// Create a div for this comment.
var context = $.extend({}, opts, comment);
var div = $(renderTemplate(commentTemplate, context));
// If the user has voted on this comment, highlight the correct arrow.
if (comment.vote) {
var direction = (comment.vote == 1) ? 'u' : 'd';
div.find('#' + direction + 'v'
|
javascript
|
{
"resource": ""
}
|
q1452
|
showError
|
train
|
function showError(message) {
$(document.createElement('div')).attr({'class': 'popup-error'})
.append($(document.createElement('div'))
.attr({'class': 'error-message'}).text(message))
|
javascript
|
{
"resource": ""
}
|
q1453
|
train
|
function(object, otherterms) {
var filenames = this._index.filenames;
var docnames = this._index.docnames;
var objects = this._index.objects;
var objnames = this._index.objnames;
var titles = this._index.titles;
var i;
var results = [];
for (var prefix in objects) {
for (var name in objects[prefix]) {
var fullname = (prefix ? prefix + '.' : '') + name;
if (fullname.toLowerCase().indexOf(object) > -1) {
var score = 0;
var parts = fullname.split('.');
// check for different match types: exact matches of full name or
// "last name" (i.e. last dotted part)
if (fullname == object || parts[parts.length - 1] == object) {
score += Scorer.objNameMatch;
// matches in last name
} else if (parts[parts.length - 1].indexOf(object) > -1) {
score += Scorer.objPartialMatch;
}
var match = objects[prefix][name];
var objname = objnames[match[1]][2];
var title = titles[match[0]];
// If more than one term searched for, we require other words to be
// found in the name/title/description
if (otherterms.length > 0) {
var haystack = (prefix + ' ' + name + ' ' +
objname + ' ' + title).toLowerCase();
var allfound = true;
for (i = 0; i < otherterms.length; i++) {
if (haystack.indexOf(otherterms[i]) == -1) {
allfound = false;
break;
}
}
|
javascript
|
{
"resource": ""
}
|
|
q1454
|
train
|
function(searchterms, excluded, terms, titleterms) {
var docnames = this._index.docnames;
var filenames = this._index.filenames;
var titles = this._index.titles;
var i, j, file;
var fileMap = {};
var scoreMap = {};
var results = [];
// perform the search on the required terms
for (i = 0; i < searchterms.length; i++) {
var word = searchterms[i];
var files = [];
var _o = [
{files: terms[word], score: Scorer.term},
{files: titleterms[word], score: Scorer.title}
];
// no match but word was a required one
if ($u.every(_o, function(o){return o.files === undefined;})) {
break;
}
// found search word in contents
$u.each(_o, function(o) {
var _files = o.files;
if (_files === undefined)
return
if (_files.length === undefined)
_files = [_files];
files = files.concat(_files);
// set score for the word in each file to Scorer.term
for (j = 0; j < _files.length; j++) {
|
javascript
|
{
"resource": ""
}
|
|
q1455
|
clean
|
train
|
function clean(args) {
return Array.prototype.filter.
|
javascript
|
{
"resource": ""
}
|
q1456
|
json
|
train
|
function json (program, callback) {
var formatterRedux = formatter(jsonRedux())
|
javascript
|
{
"resource": ""
}
|
q1457
|
getPythonExecutable
|
train
|
function getPythonExecutable(options, platform) {
if (options.virtualenv) {
var isWin = /^win/.test(platform);
var pythonExec = isWin ?
path.join(options.virtualenv, 'Scripts', 'python.exe') :
|
javascript
|
{
"resource": ""
}
|
q1458
|
getPythonCode
|
train
|
function getPythonCode(options) {
var pythonCode = [],
internalPylint = !options.externalPylint,
pylintPath = path.join(__dirname, 'lib'),
initHook = options.initHook;
delete options.initHook;
if (initHook) {
pythonCode.push(initHook);
}
if (internalPylint) {
pythonCode.push('import sys',
|
javascript
|
{
"resource": ""
}
|
q1459
|
train
|
function (options) {
var pylintArgs = [];
var enable = options.enable;
delete options.enable;
if (enable) {
pylintArgs.push('--enable=' + enable);
}
var disable = options.disable;
delete options.disable;
if (disable) {
pylintArgs.push('--disable=' + disable);
}
var messageTemplate = options.messageTemplate;
delete options.messageTemplate;
if (messageTemplate) {
var aliases = {
'short': "line {line}: {msg} ({symbol})",
'msvs': "{path}({line}): [{msg_id}({symbol}){obj}] {msg}",
'parseable': "{path}:{line}: [{msg_id}({symbol}), {obj}] {msg}",
};
if (aliases[messageTemplate] !== undefined) {
pylintArgs.push('--msg-template="' + aliases[messageTemplate] + '"');
} else {
pylintArgs.push('--msg-template="' + messageTemplate + '"');
}
}
var outputFormat = options.outputFormat;
delete options.outputFormat;
if (outputFormat) {
pylintArgs.push('--output-format=' + outputFormat);
}
var report = options.report;
delete options.report;
// Make compatible with --reports as well
if (options.reports) {
report = options.reports;
delete options.reports;
}
if (report) {
pylintArgs.push('--reports=y');
} else {
pylintArgs.push('--reports=n');
}
var rcfile = options.rcfile;
|
javascript
|
{
"resource": ""
}
|
|
q1460
|
normalizeDistance
|
train
|
function normalizeDistance(distance = 0) {
if (typeof distance !== 'object')
|
javascript
|
{
"resource": ""
}
|
q1461
|
mark
|
train
|
function mark(markName) {
if (enabled) {
marks[markName] = ts.timestamp();
counts[markName] =
|
javascript
|
{
"resource": ""
}
|
q1462
|
measure
|
train
|
function measure(measureName, startMarkName, endMarkName) {
if (enabled) {
var end = endMarkName && marks[endMarkName] || ts.timestamp();
|
javascript
|
{
"resource": ""
}
|
q1463
|
find
|
train
|
function find(array, predicate) {
for (var i = 0, len = array.length; i < len; i++) {
|
javascript
|
{
"resource": ""
}
|
q1464
|
findMap
|
train
|
function findMap(array, callback) {
for (var i = 0, len = array.length; i < len; i++) {
|
javascript
|
{
"resource": ""
}
|
q1465
|
filter
|
train
|
function filter(array, f) {
if (array) {
var len = array.length;
var i = 0;
while (i < len && f(array[i]))
i++;
if (i < len) {
var result = array.slice(0, i);
i++;
while (i < len) {
var item = array[i];
|
javascript
|
{
"resource": ""
}
|
q1466
|
getOwnKeys
|
train
|
function getOwnKeys(map) {
var keys = [];
for (var key in map)
if (hasOwnProperty.call(map, key)) {
|
javascript
|
{
"resource": ""
}
|
q1467
|
reduceProperties
|
train
|
function reduceProperties(map, callback, initial) {
var result = initial;
for (var key in map) {
|
javascript
|
{
"resource": ""
}
|
q1468
|
equalOwnProperties
|
train
|
function equalOwnProperties(left, right, equalityComparer) {
if (left === right)
return true;
if (!left || !right)
return false;
for (var key in left)
if (hasOwnProperty.call(left, key)) {
if (!hasOwnProperty.call(right, key) === undefined)
return false;
if (equalityComparer ? !equalityComparer(left[key], right[key]) : left[key] !== right[key])
return false;
|
javascript
|
{
"resource": ""
}
|
q1469
|
removeTrailingDirectorySeparator
|
train
|
function removeTrailingDirectorySeparator(path) {
if (path.charAt(path.length - 1) === ts.directorySeparator) {
return
|
javascript
|
{
"resource": ""
}
|
q1470
|
ensureTrailingDirectorySeparator
|
train
|
function ensureTrailingDirectorySeparator(path) {
if (path.charAt(path.length - 1) !== ts.directorySeparator) {
return
|
javascript
|
{
"resource": ""
}
|
q1471
|
getBasePaths
|
train
|
function getBasePaths(path, includes, useCaseSensitiveFileNames) {
// Storage for our results in the form of literal paths (e.g. the paths as written by the user).
var basePaths = [path];
if (includes) {
// Storage for literal base paths amongst the include patterns.
var includeBasePaths = [];
for (var _i = 0, includes_1 = includes; _i < includes_1.length; _i++) {
var include = includes_1[_i];
// We also need to check the relative paths by converting them to absolute and normalizing
// in case they escape the base path (e.g "..\somedirectory")
var absolute = isRootedDiskPath(include) ? include : normalizePath(combinePaths(path, include));
var wildcardOffset = indexOfAnyCharCode(absolute, wildcardCharCodes);
var includeBasePath = wildcardOffset < 0
? removeTrailingDirectorySeparator(getDirectoryPath(absolute))
: absolute.substring(0, absolute.lastIndexOf(ts.directorySeparator, wildcardOffset));
// Append the literal and canonical candidate base paths.
includeBasePaths.push(includeBasePath);
}
// Sort the offsets array using either the literal or
|
javascript
|
{
"resource": ""
}
|
q1472
|
isWhiteSpaceSingleLine
|
train
|
function isWhiteSpaceSingleLine(ch) {
// Note: nextLine is in the Zs space, and should be considered to be a whitespace.
// It is explicitly not a line-break as it isn't in the exact set specified by EcmaScript.
return ch === 32 /* space */ ||
ch === 9 /* tab */ ||
ch === 11 /* verticalTab */ ||
ch === 12 /* formFeed */ ||
ch === 160 /* nonBreakingSpace */ ||
ch === 133 /* nextLine */ ||
|
javascript
|
{
"resource": ""
}
|
q1473
|
isRequireCall
|
train
|
function isRequireCall(expression, checkArgumentIsStringLiteral) {
// of the form 'require("name")'
var isRequire = expression.kind === 174 /* CallExpression */ &&
expression.expression.kind === 69 /* Identifier */ &&
expression.expression.text === "require" &&
|
javascript
|
{
"resource": ""
}
|
q1474
|
isDeclarationOfFunctionExpression
|
train
|
function isDeclarationOfFunctionExpression(s) {
if (s.valueDeclaration && s.valueDeclaration.kind === 218 /* VariableDeclaration */) {
|
javascript
|
{
"resource": ""
}
|
q1475
|
cloneNode
|
train
|
function cloneNode(node, location, flags, parent) {
// We don't use "clone" from core.ts here, as we need to preserve the prototype chain of
// the original node. We also need to exclude specific properties and only include own-
// properties (to skip members already defined on the shared prototype).
var clone = location !== undefined
? ts.createNode(node.kind, location.pos, location.end)
: createSynthesizedNode(node.kind);
for (var key in node) {
if (clone.hasOwnProperty(key) || !node.hasOwnProperty(key)) {
|
javascript
|
{
"resource": ""
}
|
q1476
|
cloneEntityName
|
train
|
function cloneEntityName(node, parent) {
var clone = cloneNode(node, node, node.flags, parent);
if (isQualifiedName(clone)) {
|
javascript
|
{
"resource": ""
}
|
q1477
|
getExternalModuleNameFromPath
|
train
|
function getExternalModuleNameFromPath(host, fileName) {
var getCanonicalFileName = function (f) { return host.getCanonicalFileName(f); };
var dir = ts.toPath(host.getCommonSourceDirectory(), host.getCurrentDirectory(), getCanonicalFileName);
var filePath = ts.getNormalizedAbsolutePath(fileName, host.getCurrentDirectory());
|
javascript
|
{
"resource": ""
}
|
q1478
|
emitDetachedComments
|
train
|
function emitDetachedComments(text, lineMap, writer, writeComment, node, newLine, removeComments) {
var leadingComments;
var currentDetachedCommentInfo;
if (removeComments) {
// removeComments is true, only reserve pinned comment at the top of file
// For example:
// /*! Pinned Comment */
//
// var x = 10;
if (node.pos === 0) {
leadingComments = ts.filter(ts.getLeadingCommentRanges(text, node.pos), isPinnedComment);
}
}
else {
// removeComments is false, just get detached as normal and bypass the process to filter comment
leadingComments = ts.getLeadingCommentRanges(text, node.pos);
}
if (leadingComments) {
var detachedComments = [];
var lastComment = void 0;
for (var _i = 0, leadingComments_1 = leadingComments; _i < leadingComments_1.length; _i++) {
var comment = leadingComments_1[_i];
if (lastComment) {
var lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, lastComment.end);
var commentLine = getLineOfLocalPositionFromLineMap(lineMap, comment.pos);
if (commentLine >= lastCommentLine + 2) {
// There was a blank line between the last comment and this comment. This
// comment is not part of the copyright comments. Return what we have so
// far.
break;
}
}
detachedComments.push(comment);
lastComment = comment;
}
if (detachedComments.length) {
// All comments look like they could have been part of the copyright header.
|
javascript
|
{
"resource": ""
}
|
q1479
|
tryExtractTypeScriptExtension
|
train
|
function tryExtractTypeScriptExtension(fileName) {
return ts.find(ts.supportedTypescriptExtensionsForExtractExtension,
|
javascript
|
{
"resource": ""
}
|
q1480
|
convertToBase64
|
train
|
function convertToBase64(input) {
var result = "";
var charCodes = getExpandedCharCodes(input);
var i = 0;
var length = charCodes.length;
var byte1, byte2, byte3, byte4;
while (i < length) {
// Convert every 6-bits in the input 3 character points
// into a base64 digit
byte1 = charCodes[i] >> 2;
byte2 = (charCodes[i] & 3) << 4 | charCodes[i + 1] >> 4;
|
javascript
|
{
"resource": ""
}
|
q1481
|
collapseTextChangeRangesAcrossMultipleVersions
|
train
|
function collapseTextChangeRangesAcrossMultipleVersions(changes) {
if (changes.length === 0) {
return ts.unchangedTextChangeRange;
}
if (changes.length === 1) {
return changes[0];
}
// We change from talking about { { oldStart, oldLength }, newLength } to { oldStart, oldEnd, newEnd }
// as it makes things much easier to reason about.
var change0 = changes[0];
var oldStartN = change0.span.start;
var oldEndN = textSpanEnd(change0.span);
var newEndN = oldStartN + change0.newLength;
for (var i = 1; i < changes.length; i++) {
var nextChange = changes[i];
// Consider the following case:
// i.e. two edits. The first represents the text change range { { 10, 50 }, 30 }. i.e. The span starting
// at 10, with length 50 is reduced to length 30. The second represents the text change range { { 30, 30 }, 40 }.
// i.e. the span starting at 30 with length 30 is increased to length 40.
//
// 0 10 20 30 40 50 60 70 80 90 100
// -------------------------------------------------------------------------------------------------------
// | /
// | /----
// T1 | /----
// | /----
// | /----
// -------------------------------------------------------------------------------------------------------
// | \
// | \
// T2 | \
// | \
// | \
// -------------------------------------------------------------------------------------------------------
//
// Merging these turns out to not be too difficult. First, determining the new start of the change is trivial
// it's just the min of the old and new starts. i.e.:
//
// 0 10 20 30 40 50 60 70 80 90 100
// ------------------------------------------------------------*------------------------------------------
// | /
// | /----
// T1 | /----
// | /----
// | /----
// ----------------------------------------$-------------------$------------------------------------------
// . | \
// . | \
// T2 . | \
// . | \
// . | \
// ----------------------------------------------------------------------*--------------------------------
//
// (Note the dots represent the newly inferred start.
// Determining the new and old end is also pretty simple. Basically it boils down to paying attention to the
// absolute positions at the asterisks, and the relative change between the dollar signs. Basically, we see
// which if the two $'s precedes the other, and we move that one forward until they line up. in this case that
// means:
//
// 0 10 20 30 40 50 60 70 80 90 100
// --------------------------------------------------------------------------------*----------------------
// | /
// | /----
// T1 | /----
// |
|
javascript
|
{
"resource": ""
}
|
q1482
|
isIdentifier
|
train
|
function isIdentifier() {
if (token() === 69 /* Identifier */) {
return true;
}
// If we have a 'yield' keyword, and we're in the [yield] context, then 'yield' is
// considered a keyword and is not an identifier.
if (token() === 114 /* YieldKeyword */ && inYieldContext()) {
return false;
}
// If we have a 'await' keyword, and we're in the [Await] context, then 'await' is
|
javascript
|
{
"resource": ""
}
|
q1483
|
isListElement
|
train
|
function isListElement(parsingContext, inErrorRecovery) {
var node = currentNode(parsingContext);
if (node) {
return true;
}
switch (parsingContext) {
case 0 /* SourceElements */:
case 1 /* BlockStatements */:
case 3 /* SwitchClauseStatements */:
// If we're in error recovery, then we don't want to treat ';' as an empty statement.
// The problem is that ';' can show up in far too many contexts, and if we see one
// and assume it's a statement, then we may bail out inappropriately from whatever
// we're parsing. For example, if we have a semicolon in the middle of a class, then
// we really don't want to assume the class is over and we're on a statement in the
// outer module. We just want to consume and move on.
return !(token() === 23 /* SemicolonToken */ && inErrorRecovery) && isStartOfStatement();
case 2 /* SwitchClauses */:
return token() === 71 /* CaseKeyword */ || token() === 77 /* DefaultKeyword */;
case 4 /* TypeMembers */:
return lookAhead(isTypeMemberStart);
case 5 /* ClassMembers */:
// We allow semicolons as class elements (as specified by ES6) as long as we're
// not in error recovery. If we're in error recovery, we don't want an errant
// semicolon to be treated as a class member (since they're almost always used
// for statements.
return lookAhead(isClassMemberStart) || (token() === 23 /* SemicolonToken */ && !inErrorRecovery);
case 6 /* EnumMembers */:
// Include open bracket computed properties. This technically also lets in indexers,
// which would be a candidate for improved error reporting.
return token() === 19 /* OpenBracketToken */ || isLiteralPropertyName();
case 12 /* ObjectLiteralMembers */:
return token() === 19 /* OpenBracketToken */ || token() === 37 /* AsteriskToken */ || isLiteralPropertyName();
case 9 /* ObjectBindingElements */:
return token() === 19 /* OpenBracketToken */ || isLiteralPropertyName();
case 7 /* HeritageClauseElement */:
// If we see { } then only consume it as an expression if it is followed by , or {
// That way we won't consume the body of a class in its heritage clause.
if (token() === 15 /* OpenBraceToken */) {
return lookAhead(isValidHeritageClauseObjectLiteral);
}
if (!inErrorRecovery) {
return isStartOfLeftHandSideExpression() && !isHeritageClauseExtendsOrImplementsKeyword();
}
else {
// If we're in error recovery we tighten up what we're willing to match.
// That way we don't treat something like "this" as a valid heritage clause
// element during recovery.
return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword();
}
case 8 /* VariableDeclarations */:
return isIdentifierOrPattern();
|
javascript
|
{
"resource": ""
}
|
q1484
|
isInSomeParsingContext
|
train
|
function isInSomeParsingContext() {
for (var kind = 0; kind < 26 /* Count */; kind++) {
if (parsingContext & (1 << kind)) {
if (isListElement(kind, /*inErrorRecovery*/ true) || isListTerminator(kind)) {
|
javascript
|
{
"resource": ""
}
|
q1485
|
parseList
|
train
|
function parseList(kind, parseElement) {
var saveParsingContext = parsingContext;
parsingContext |= 1 << kind;
var result = [];
result.pos = getNodePos();
while (!isListTerminator(kind)) {
if (isListElement(kind, /*inErrorRecovery*/ false)) {
var element = parseListElement(kind, parseElement);
result.push(element);
continue;
|
javascript
|
{
"resource": ""
}
|
q1486
|
parseDelimitedList
|
train
|
function parseDelimitedList(kind, parseElement, considerSemicolonAsDelimiter) {
var saveParsingContext = parsingContext;
parsingContext |= 1 << kind;
var result = [];
result.pos = getNodePos();
var commaStart = -1; // Meaning the previous token was not a comma
while (true) {
if (isListElement(kind, /*inErrorRecovery*/ false)) {
result.push(parseListElement(kind, parseElement));
commaStart = scanner.getTokenPos();
if (parseOptional(24 /* CommaToken */)) {
continue;
}
commaStart = -1; // Back to the state where the last token was not a comma
if (isListTerminator(kind)) {
break;
}
// We didn't get a comma, and the list wasn't terminated, explicitly parse
// out a comma so we give a good error message.
parseExpected(24 /* CommaToken */);
// If the token was a semicolon, and the caller allows that, then skip it and
// continue. This ensures we get back on track and don't result in tons of
// parse errors. For example, this can happen when people do things like use
// a semicolon to delimit object literal members. Note: we'll have already
// reported an error when we called parseExpected above.
if (considerSemicolonAsDelimiter && token() === 23 /* SemicolonToken */ && !scanner.hasPrecedingLineBreak()) {
nextToken();
}
continue;
}
|
javascript
|
{
"resource": ""
}
|
q1487
|
parseUnaryExpressionOrHigher
|
train
|
function parseUnaryExpressionOrHigher() {
/**
* ES7 UpdateExpression:
* 1) LeftHandSideExpression[?Yield]
* 2) LeftHandSideExpression[?Yield][no LineTerminator here]++
* 3) LeftHandSideExpression[?Yield][no LineTerminator here]--
* 4) ++UnaryExpression[?Yield]
* 5) --UnaryExpression[?Yield]
*/
if (isUpdateExpression()) {
var incrementExpression = parseIncrementExpression();
return token() === 38 /* AsteriskAsteriskToken */ ?
parseBinaryExpressionRest(getBinaryOperatorPrecedence(), incrementExpression) :
incrementExpression;
}
/**
* ES7 UnaryExpression:
* 1) UpdateExpression[?yield]
* 2) delete UpdateExpression[?yield]
* 3) void UpdateExpression[?yield]
* 4) typeof UpdateExpression[?yield]
* 5) + UpdateExpression[?yield]
* 6) - UpdateExpression[?yield]
* 7) ~ UpdateExpression[?yield]
* 8) ! UpdateExpression[?yield]
*/
|
javascript
|
{
"resource": ""
}
|
q1488
|
parseIncrementExpression
|
train
|
function parseIncrementExpression() {
if (token() === 41 /* PlusPlusToken */ || token() === 42 /* MinusMinusToken */) {
var node = createNode(185 /* PrefixUnaryExpression */);
node.operator = token();
nextToken();
node.operand = parseLeftHandSideExpressionOrHigher();
return finishNode(node);
}
else if (sourceFile.languageVariant === 1 /* JSX */ && token() === 25 /* LessThanToken */ && lookAhead(nextTokenIsIdentifierOrKeyword)) {
// JSXElement is part of primaryExpression
return parseJsxElementOrSelfClosingElement(/*inExpressionContext*/ true);
}
var expression = parseLeftHandSideExpressionOrHigher();
|
javascript
|
{
"resource": ""
}
|
q1489
|
parseEnumMember
|
train
|
function parseEnumMember() {
var node = createNode(255 /* EnumMember */, scanner.getStartPos());
node.name = parsePropertyName();
|
javascript
|
{
"resource": ""
}
|
q1490
|
tryFile
|
train
|
function tryFile(fileName, failedLookupLocation, onlyRecordFailures, state) {
if (!onlyRecordFailures && state.host.fileExists(fileName)) {
if (state.traceEnabled) {
ts.trace(state.host, ts.Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName);
}
return fileName;
}
else {
if (state.traceEnabled) {
|
javascript
|
{
"resource": ""
}
|
q1491
|
tryAddingExtensions
|
train
|
function tryAddingExtensions(candidate, extensions, failedLookupLocation, onlyRecordFailures, state) {
if (!onlyRecordFailures) {
// check if containing folder exists - if it doesn't then just record failures for all supported extensions without disk probing
var directory = ts.getDirectoryPath(candidate);
if (directory) {
onlyRecordFailures = !directoryProbablyExists(directory, state.host);
}
}
|
javascript
|
{
"resource": ""
}
|
q1492
|
getDeclarationName
|
train
|
function getDeclarationName(node) {
if (node.name) {
if (ts.isAmbientModule(node)) {
return ts.isGlobalScopeAugmentation(node) ? "__global" : "\"" + node.name.text + "\"";
}
if (node.name.kind === 140 /* ComputedPropertyName */) {
var nameExpression = node.name.expression;
// treat computed property names where expression is string/numeric literal as just string/numeric literal
if (ts.isStringOrNumericLiteral(nameExpression.kind)) {
return nameExpression.text;
}
ts.Debug.assert(ts.isWellKnownSymbolSyntactically(nameExpression));
return ts.getPropertyNameForKnownSymbolName(nameExpression.name.text);
}
return node.name.text;
}
switch (node.kind) {
case 148 /* Constructor */:
return "__constructor";
case 156 /* FunctionType */:
case 151 /* CallSignature */:
return "__call";
case 157 /* ConstructorType */:
case 152 /* ConstructSignature */:
return "__new";
case 153 /* IndexSignature */:
return "__index";
case 236 /* ExportDeclaration */:
return "__export";
case 235 /* ExportAssignment */:
return node.isExportEquals ? "export=" : "default";
case 187 /* BinaryExpression */:
|
javascript
|
{
"resource": ""
}
|
q1493
|
declareSymbol
|
train
|
function declareSymbol(symbolTable, parent, node, includes, excludes) {
ts.Debug.assert(!ts.hasDynamicName(node));
var isDefaultExport = node.flags & 512 /* Default */;
// The exported symbol for an export default function/class node is always named "default"
var name = isDefaultExport && parent ? "default" : getDeclarationName(node);
var symbol;
if (name === undefined) {
symbol = createSymbol(0 /* None */, "__missing");
}
else {
// Check and see if the symbol table already has a symbol with this name. If not,
// create a new symbol with this name and add it to the table. Note that we don't
// give the new symbol any flags *yet*. This ensures that it will not conflict
// with the 'excludes' flags we pass in.
//
// If we do get an existing symbol, see if it conflicts with the new symbol we're
// creating. For example, a 'var' symbol and a 'class' symbol will conflict within
// the same symbol table. If we have a conflict, report the issue on each
// declaration we have for this symbol, and then create a new symbol for this
// declaration.
//
// Note that when properties declared in Javascript constructors
// (marked by isReplaceableByMethod) conflict with another symbol, the property loses.
// Always. This allows the common Javascript pattern of overwriting a prototype method
// with an bound instance method of the same type: `this.method = this.method.bind(this)`
//
// If we created a new symbol, either because we didn't have a symbol with this name
//
|
javascript
|
{
"resource": ""
}
|
q1494
|
bindContainer
|
train
|
function bindContainer(node, containerFlags) {
// Before we recurse into a node's children, we first save the existing parent, container
// and block-container. Then after we pop out of processing the children, we restore
// these saved values.
var saveContainer = container;
var savedBlockScopeContainer = blockScopeContainer;
// Depending on what kind of node this is, we may have to adjust the current container
// and block-container. If the current node is a container, then it is automatically
// considered the current block-container as well. Also, for containers that we know
// may contain locals, we proactively initialize the .locals field. We do this because
// it's highly likely that the .locals will be needed to place some child in (for example,
// a parameter, or variable declaration).
//
// However, we do not proactively create the .locals for block-containers because it's
// totally normal and common for block-containers to never actually have a block-scoped
// variable in them. We don't want to end up allocating an object for every 'block' we
// run into when most of them won't be necessary.
//
// Finally, if this is a block-container, then we clear out any existing .locals object
// it may contain within it. This happens in incremental scenarios. Because we can be
// reusing a node from a previous compilation, that node may have had 'locals' created
// for it. We must clear this so we don't accidentally move any stale data forward from
// a previous compilation.
if (containerFlags & 1 /* IsContainer */) {
container = blockScopeContainer = node;
if (containerFlags & 32 /* HasLocals */) {
container.locals = ts.createMap();
}
addToContainerChain(container);
}
else if (containerFlags & 2 /* IsBlockScopedContainer */) {
blockScopeContainer = node;
blockScopeContainer.locals = undefined;
}
if (containerFlags & 4 /* IsControlFlowContainer */) {
var saveCurrentFlow = currentFlow;
var saveBreakTarget = currentBreakTarget;
var saveContinueTarget = currentContinueTarget;
var saveReturnTarget = currentReturnTarget;
var saveActiveLabels = activeLabels;
var saveHasExplicitReturn = hasExplicitReturn;
var isIIFE = containerFlags & 16 /* IsFunctionExpression */ && !!ts.getImmediatelyInvokedFunctionExpression(node);
// An IIFE is considered part of the containing control flow. Return statements behave
// similarly to break statements that exit to a label just past the statement body.
if (isIIFE) {
currentReturnTarget = createBranchLabel();
}
else {
currentFlow = { flags: 2 /* Start */ };
if (containerFlags & 16 /* IsFunctionExpression */) {
currentFlow.container = node;
}
currentReturnTarget = undefined;
}
currentBreakTarget = undefined;
currentContinueTarget = undefined;
activeLabels = undefined;
hasExplicitReturn = false;
|
javascript
|
{
"resource": ""
}
|
q1495
|
checkStrictModeIdentifier
|
train
|
function checkStrictModeIdentifier(node) {
if (inStrictMode &&
node.originalKeywordKind >= 106 /* FirstFutureReservedWord */ &&
node.originalKeywordKind <= 114 /* LastFutureReservedWord */ &&
!ts.isIdentifierName(node) &&
|
javascript
|
{
"resource": ""
}
|
q1496
|
getSymbolsOfParameterPropertyDeclaration
|
train
|
function getSymbolsOfParameterPropertyDeclaration(parameter, parameterName) {
var constructorDeclaration = parameter.parent;
var classDeclaration = parameter.parent.parent;
var parameterSymbol = getSymbol(constructorDeclaration.locals, parameterName, 107455 /* Value */);
var propertySymbol = getSymbol(classDeclaration.symbol.members, parameterName, 107455 /* Value */);
|
javascript
|
{
"resource": ""
}
|
q1497
|
getEntityNameForExtendingInterface
|
train
|
function getEntityNameForExtendingInterface(node) {
switch (node.kind) {
case 69 /* Identifier */:
case 172 /* PropertyAccessExpression */:
return node.parent ? getEntityNameForExtendingInterface(node.parent) : undefined;
case 194 /* ExpressionWithTypeArguments */:
|
javascript
|
{
"resource": ""
}
|
q1498
|
getSymbolOfPartOfRightHandSideOfImportEquals
|
train
|
function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, importDeclaration, dontResolveAlias) {
// There are three things we might try to look for. In the following examples,
// the search term is enclosed in |...|:
//
// import a = |b|; // Namespace
// import a = |b.c|; // Value, type, namespace
// import a = |b.c|.d; // Namespace
if (entityName.kind === 69 /* Identifier */ && ts.isRightSideOfQualifiedNameOrPropertyAccess(entityName)) {
|
javascript
|
{
"resource": ""
}
|
q1499
|
extendExportSymbols
|
train
|
function extendExportSymbols(target, source, lookupTable, exportNode) {
for (var id in source) {
if (id !== "default" && !target[id]) {
target[id] = source[id];
if (lookupTable && exportNode) {
lookupTable[id] = {
specifierText: ts.getTextOfNode(exportNode.moduleSpecifier)
};
}
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.