_id
stringlengths 2
6
| title
stringlengths 0
58
| partition
stringclasses 3
values | text
stringlengths 52
373k
| 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);
}
});
matchingTargets.forEach(function(matchingTarget) {
grunt.event.emit('watch', status, filepath, matchingTarget);
});
}
// Keep track of changed status for later.
changedFiles[filepath] = status;
// Execute debounced done function.
done();
}
|
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 file has dissapeared in between
return;
}
watchedFiles[filepath] = statStructure;
mtimes[filepath] = +watchedFiles[filepath].mtime;
}
}
|
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' ) {
// convert nodeList to array
for ( var i=0, len = obj.length; i < len; i++ ) {
ary.push( obj[i] );
}
} else {
// array of single index
ary.push( obj );
}
return ary;
}
|
javascript
|
{
"resource": ""
}
|
q1403
|
train
|
function(context, pkg, source) {
source = source || "{}";
var packageJSON = JSON.parse(source);
utils.extend(pkg, packageJSON);
context.packages.push(pkg);
return pkg;
}
|
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 = crawl.loadSteal(context, pkg, true, deps);
return Promise.all([pluginsPromise, 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' so that the builtins will be configured
if(childPkg && childPkg.name === 'steal') {
return crawl.deps(context, childPkg);
}
})).then(function(){
return packages;
});
});
}
|
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 it
// does ... do nothing
if(crawl.hasParentPackageThatMatches(context, childPkg)) {
return;
}
if(crawl.isSameRequestedVersionFound(context, childPkg)) {
return;
}
var requestedVersion = childPkg.version;
return npmLoad(context, childPkg, requestedVersion)
.then(function(pkg){
crawl.setVersionsConfig(context, pkg, requestedVersion);
return pkg;
});
}
|
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){
if(childPkg) {
return crawl.deps(context, childPkg);
}
});
} else {
return Promise.resolve();
}
}
|
javascript
|
{
"resource": ""
}
|
|
q1408
|
train
|
function(loader, packageJSON, isRoot){
var deps = crawl.getDependencyMap(loader, packageJSON, isRoot);
var dependencies = [];
for(var name in deps) {
dependencies.push(deps[name]);
}
return 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);
}
npmIgnore = npmIgnore || {};
var deps = {};
addDeps(packageJSON, packageJSON.peerDependencies || {}, deps,
"peerDependencies", {_isPeerDependency: true});
addDeps(packageJSON, packageJSON.dependencies || {}, deps, "dependencies");
if(isRoot) {
addDeps(packageJSON, packageJSON.devDependencies || {}, deps,
"devDependencies");
}
return deps;
}
|
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)) {
return parentPkg.fileUrl;
} else {
return curAddress;
}
}
parentAddress = utils.path.parentNodeModuleAddress(packageAddress);
curAddress = packageAddress;
}
return curAddress;
}
|
javascript
|
{
"resource": ""
}
|
|
q1411
|
train
|
function(pkg){
var pkg = pkg || this.getPackage();
var requestedVersion = this.requestedVersion;
return SemVer.validRange(requestedVersion) &&
SemVer.valid(pkg.version) ?
SemVer.satisfies(pkg.version, requestedVersion) : true;
}
|
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 reason as
// the first did
if (currentTaskIsCompatible && (!firstTaskFailed || firstTaskIsNotCompatible)) {
task.failed = false;
task.error = null;
}
else if (!currentTaskIsCompatible) {
task.failed = true;
task.error = new Error("Incompatible package version requested");
}
else if (firstTaskFailed) {
task.failed = true;
task.error = loadingTask.error;
}
});
}
|
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 = this.context.paths[this.fileUrl];
if(loadedPkg) {
this._fetchedPackage = loadedPkg;
if(!this.isCompatibleVersion()) {
this.failed = true;
}
return Promise.resolve();
}
}
|
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) {
throw new Error('Did not find ' + pkg.origFileUrl);
}
var nodeModuleAddress = parentAddress + "/" + pkg.name +
"/package.json";
pkg.nextFileUrl = nodeModuleAddress;
}
return pkg;
}
|
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 being the parent node_modules folder.
return npmLoad(context, task.next());
}
return task.getPackage();
});
}
|
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
if (m.a == m.d) {text = 'scale(' + m.a + ')';}
else {text = 'scale(' + m.a + ',' + m.d + ')';}
break;
case 4: // ROTATE
var cx = 0, cy = 0;
// this prevents divide by zero
if (xform.angle != 0) {
var K = 1 - m.a;
cy = ( K * m.f + m.b*m.e ) / ( K*K + m.b*m.b );
cx = ( m.e - m.b * cy ) / K;
}
text = 'rotate(' + xform.angle + ' ' + cx + ',' + cy + ')';
break;
}
return text;
}
|
javascript
|
{
"resource": ""
}
|
q1417
|
basicIdentityIsSet
|
train
|
function basicIdentityIsSet(){
return _.has(user, 'identities') && _.has(user.identities, 'basic') && !_.isEmpty(user.identities.basic);
}
|
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"));
}
const rNotFound = /^[\w\-]+ not found/g;
if (rNotFound.test(cmd)) {
return Promise.resolve(false);
}
return Promise.resolve(true);
});
}
|
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 + ')');
}
this._ref = firebaseRef;
if (promise && promise.then) {
this.then = promise.then.bind(promise);
} else {
this.then = function(ok, fail) {
return this.once('value', function() {})
.then(ok || null, fail || null);
};
}
}
|
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) {
updateToolbar();
}
} // if (elem != null)
// Deal with pathedit mode
togglePathEditMode(is_node, elems);
updateContextPanel();
svgCanvas.runExtensions('selectedChanged', {
elems: elems,
selectedElement: selectedElement,
multiselected: multiselected
});
}
|
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);
$('#tool_reorient').toggleClass('disabled', ang === 0);
break;
// TODO: Update values that change on move/resize, etc
// case "select":
// case "resize":
// break;
}
}
svgCanvas.runExtensions('elementTransition', {
elems: elems
});
}
|
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
// positional/sizing information (we DON'T want to update the
// toolbar here as that creates an infinite loop)
// also this updates the history buttons
// we tell it to skip focusing the text control if the
// text element was previously in focus
updateContextPanel();
// In the event a gradient was flipped:
if (selectedElement && mode === 'select') {
paintBox.fill.update();
paintBox.stroke.update();
}
svgCanvas.runExtensions('elementChanged', {
elems: elems
});
}
|
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) {
icon = $.getSvgIcon(options.icon, true);
} else {
icon = $(options.sel).children().eq(0).clone();
}
icon[0].setAttribute('width', shower.width());
icon[0].setAttribute('height', shower.height());
shower.children(':not(.flyout_arrow_horiz)').remove();
shower.append(icon).attr('data-curopt', options.sel); // This sets the current mode
}
|
javascript
|
{
"resource": ""
}
|
|
q1424
|
train
|
function(close) {
var w = $('#sidepanels').width();
var deltaX = (w > 2 || close ? 2 : SIDEPANEL_OPENWIDTH) - w;
changeSidePanelWidth(deltaX);
}
|
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'
}
});
svgCanvas.setHref(newImage, e.target.result);
svgCanvas.selectOnly([newImage]);
svgCanvas.alignSelectedElements('m', 'page');
svgCanvas.alignSelectedElements('c', 'page');
updateContextPanel();
}
|
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") {
// simulate textinput
return true;
}
} else {
// reset
data.$lastHash = hashId;
data.$lastKey = key;
data.lastEvent = "keypress";
}
}
|
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 not.
if(root) {
value = convertName(context, pkg, map, false, property, waiting);
if(typeof value === 'string') {
clone[value] = map[property];
}
}
}
return clone;
}
|
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"
? convertPropertyNamesAndValues(context, pkg, val, root, waiting)
: convertName(context, pkg, map, root, val, waiting);
if(typeof name !== 'undefined' && typeof val !== 'undefined') {
clone[name] = val;
}
}
return clone;
}
|
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) {
convertBrowserProperty(map, pkg, fromName, browser[fromName]);
}
return map;
}
|
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 pkgConv) {
depPkg = crawl.matchedVersion(context, name, range);
if(depPkg) {
fns = pkgConv[range];
for(var i = 0, len = fns.length; i < len; i++) {
fns[i].call(context);
}
delete pkgConv[range];
} else {
keys++;
}
}
if(keys === 0) {
delete conv[name];
}
}
}
|
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() {
cancelled = true;
$('#dialog_box').hide();
});
}
if(form[0] == open_svg_form[0]) {
inp.change(function() {
// This takes care of the "are you sure" dialog box
svgEditor.openPrep(function(ok) {
if(!ok) {
rebuildInput(form);
return;
}
submit();
});
});
} else {
inp.change(function() {
// This submits the form, which returns the file data using svgEditor.processFile()
submit();
});
}
}
|
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) {
if (compare(candidate, largest) > 0) {
largest = candidate;
}
}
return largest;
}
|
javascript
|
{
"resource": ""
}
|
q1433
|
train
|
function() {
self.value += stepValue;
self.setValue(self.value);
self.triggerScrollEvent(self.value);
if (isFinishedScrolling()) {
clearInterval(self.pageScrollTimer);
}
}
|
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',
captionClass: 'jcf-optgroup-caption',
disabledClass: 'jcf-disabled',
optionClass: 'jcf-option',
groupClass: 'jcf-optgroup',
hoverClass: 'jcf-hover',
selectedClass: 'jcf-selected',
scrollClass: 'jcf-scroll-active'
}, options);
this.init();
}
|
javascript
|
{
"resource": ""
}
|
q1435
|
isSerializedHelper
|
train
|
function isSerializedHelper(obj){
if (typeReflections.isPrimitive(obj)) {
return true;
}
if(hasUpdateSymbol(obj)) {
return false;
}
return typeReflections.isBuiltIn(obj) && !typeReflections.isPlainObject(obj) && !Array.isArray(obj);
}
|
javascript
|
{
"resource": ""
}
|
q1436
|
train
|
function(obj){
var hasOwnKey = obj[canSymbol.for("can.hasOwnKey")];
if(hasOwnKey) {
return hasOwnKey.bind(obj);
} else {
var map = makeMap( shapeReflections.getOwnEnumerableKeys(obj) );
return function(key) {
return map.get(key);
};
}
}
|
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) ) {
lastPatch.insert.push.apply(lastPatch.insert, patch.insert);
lastPatch.deleteCount += patch.deleteCount;
return;
}
}
patches.push(patch);
}
|
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) { return b[by] - a[by]; };
}
// Reset link styles and format the selected sort option.
$('a.sel').attr('href', '#').removeClass('sel');
$('a.by' + by).removeAttr('href').addClass('sel');
}
|
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(";", start);
if (end == -1) {
end = document.cookie.length;
by = unescape(document.cookie.substring(start, end));
}
}
}
setComparator();
}
|
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);
form.submit(function(event) {
event.preventDefault();
addComment(form);
});
$('#s' + id).after(popup);
popup.slideDown('fast', function() {
getComments(id);
});
}
|
javascript
|
{
"resource": ""
}
|
q1441
|
hide
|
train
|
function hide(id) {
$('#ah' + id).hide();
$('#ao' + id).show();
var div = $('#sc' + id);
div.slideUp('fast', function() {
div.remove();
});
}
|
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;
appendComments(comments, ul);
ul.data('empty', false);
}
$('#cn' + id).slideUp(speed + 200);
ul.slideDown(speed);
},
error: function(request, textStatus, error) {
showError('Oops, there was a problem retrieving the comments.');
},
dataType: 'json'
});
}
|
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();
ul.data('empty', false);
}
insertComment(data.comment);
var ao = $('#ao' + node_id);
ao.find('img').attr({'src': opts.commentBrightImage});
if (node_id) {
// if this was a "root" comment, remove the commenting box
// (the user can get it back by reopening the comment popup)
$('#ca' + node_id).slideUp();
}
},
error: function(request, textStatus, error) {
form.find('textarea,input').removeAttr('disabled');
showError('Oops, there was a problem adding the comment.');
}
});
}
|
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 data, don't store the comments children in data.
this.children = null;
div.data('comment', this);
});
}
|
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()
.before(li.html(div));
li.slideDown('fast');
return;
}
}
// If we get here, this comment rates lower than all the others,
// or it is the only comment in the list.
ul.append(li.html(div));
li.slideDown('fast');
}
|
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) +
';expires=' + expiration.toUTCString();
$('ul.comment-ul').each(function(index, ul) {
var comments = getChildren($(ul), true);
comments = sortComments(comments);
appendComments(comments, $(ul).empty());
});
}
|
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();
// The div the comment is displayed in.
var div = $('div#cd' + d.comment_id);
var data = div.data('comment');
// If this is not an unvote, and the other vote arrow has
// already been pressed, unpress it.
if ((d.value !== 0) && (data.vote === d.value * -1)) {
$('#' + (d.value == 1 ? 'd' : 'u') + 'u' + d.comment_id).hide();
$('#' + (d.value == 1 ? 'd' : 'u') + 'v' + d.comment_id).show();
}
// Update the comments rating in the local data.
data.rating += (data.vote === 0) ? d.value : (d.value - data.vote);
data.vote = d.value;
div.data('comment', data);
// Change the rating text.
div.find('.rating:first')
.text(data.rating + ' point' + (data.rating == 1 ? '' : 's'));
// Send the vote information to the server.
$.ajax({
type: "POST",
url: opts.processVoteURL,
data: d,
error: function(request, textStatus, error) {
showError('Oops, there was a problem casting that vote.');
}
});
}
|
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) {
event.preventDefault();
addComment($('#rf' + id));
closeReply(id);
})
.find('input[type=button]')
.click(function() {
closeReply(id);
});
div.slideDown('fast', function() {
$('#rf' + id).find('textarea').focus();
});
}
|
javascript
|
{
"resource": ""
}
|
q1449
|
sortComments
|
train
|
function sortComments(comments) {
comments.sort(comp);
$.each(comments, function() {
this.children = sortComments(this.children);
});
return comments;
}
|
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)
comment.children = getChildren($(this).find('#cl' + comment.id), true);
children.push(comment);
});
return children;
}
|
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' + comment.id).hide();
div.find('#' + direction + 'u' + comment.id).show();
}
if (opts.moderator || comment.text != '[deleted]') {
div.find('a.reply').show();
if (comment.proposal_diff)
div.find('#sp' + comment.id).show();
if (opts.moderator && !comment.displayed)
div.find('#cm' + comment.id).show();
if (opts.moderator || (opts.username == comment.username))
div.find('#dc' + comment.id).show();
}
return div;
}
|
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))
.appendTo('body')
.fadeIn("slow")
.delay(2000)
.fadeOut("slow");
}
|
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;
}
}
if (!allfound) {
continue;
}
}
var descr = objname + _(', in ') + title;
var anchor = match[3];
if (anchor === '')
anchor = fullname;
else if (anchor == '-')
anchor = objnames[match[1]][1] + '-' + fullname;
// add custom score for some objects according to scorer
if (Scorer.objPrio.hasOwnProperty(match[2])) {
score += Scorer.objPrio[match[2]];
} else {
score += Scorer.objPrioDefault;
}
results.push([docnames[match[0]], fullname, '#'+anchor, descr, score, filenames[match[0]]]);
}
}
}
return results;
}
|
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++) {
file = _files[j];
if (!(file in scoreMap))
scoreMap[file] = {}
scoreMap[file][word] = o.score;
}
});
// create the mapping
for (j = 0; j < files.length; j++) {
file = files[j];
if (file in fileMap)
fileMap[file].push(word);
else
fileMap[file] = [word];
}
}
// now check if the files don't contain excluded terms
for (file in fileMap) {
var valid = true;
// check if all requirements are matched
if (fileMap[file].length != searchterms.length)
continue;
// ensure that none of the excluded terms is in the search result
for (i = 0; i < excluded.length; i++) {
if (terms[excluded[i]] == file ||
titleterms[excluded[i]] == file ||
$u.contains(terms[excluded[i]] || [], file) ||
$u.contains(titleterms[excluded[i]] || [], file)) {
valid = false;
break;
}
}
// if we have still a valid result we can add it to the result list
if (valid) {
// select one (max) score for the file.
// for better ranking, we should calculate ranking by using words statistics like basic tf-idf...
var score = $u.max($u.map(fileMap[file], function(w){return scoreMap[file][w]}));
results.push([docnames[file], titles[file], '', null, score, filenames[file]]);
}
}
return results;
}
|
javascript
|
{
"resource": ""
}
|
|
q1455
|
clean
|
train
|
function clean(args) {
return Array.prototype.filter.call(args, v => v !== INVALIDATE);
}
|
javascript
|
{
"resource": ""
}
|
q1456
|
json
|
train
|
function json (program, callback) {
var formatterRedux = formatter(jsonRedux())
parse(program.stdin, program.stderr, printer(formatterRedux, program.stdout, program.stderr), callback)
}
|
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') :
path.join(options.virtualenv, 'bin', 'python');
delete options.virtualenv;
return pythonExec;
} else {
return 'python';
}
}
|
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', 'sys.path.insert(0, r"' + pylintPath + '")');
}
pythonCode.push('import pylint', 'pylint.run_pylint()');
delete options.externalPylint;
return pythonCode.join('; ');
}
|
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;
delete options.rcfile;
if (rcfile) {
pylintArgs.push('--rcfile=' + rcfile);
}
var score = options.score;
delete options.score;
if (score) {
pylintArgs.push('--score=y');
} else {
pylintArgs.push('--score=n');
}
var errorsOnly = options.errorsOnly;
delete options.errorsOnly;
if (errorsOnly) {
pylintArgs.push('--errors-only');
}
var ignore = options.ignore;
delete options.ignore;
if (ignore) {
pylintArgs.push('--ignore=' + ignore);
}
// Fail if there's any options remaining now
for (var prop in options) {
if (options.hasOwnProperty(prop)) {
grunt.fail.warn("Unknown option to pylint: '" + prop + "'");
}
}
return pylintArgs;
}
|
javascript
|
{
"resource": ""
}
|
|
q1460
|
normalizeDistance
|
train
|
function normalizeDistance(distance = 0) {
if (typeof distance !== 'object') distance = { top: distance, left: distance, right: distance, bottom: distance };
return distance;
}
|
javascript
|
{
"resource": ""
}
|
q1461
|
mark
|
train
|
function mark(markName) {
if (enabled) {
marks[markName] = ts.timestamp();
counts[markName] = (counts[markName] || 0) + 1;
profilerEvent(markName);
}
}
|
javascript
|
{
"resource": ""
}
|
q1462
|
measure
|
train
|
function measure(measureName, startMarkName, endMarkName) {
if (enabled) {
var end = endMarkName && marks[endMarkName] || ts.timestamp();
var start = startMarkName && marks[startMarkName] || profilerStart;
measures[measureName] = (measures[measureName] || 0) + (end - start);
}
}
|
javascript
|
{
"resource": ""
}
|
q1463
|
find
|
train
|
function find(array, predicate) {
for (var i = 0, len = array.length; i < len; i++) {
var value = array[i];
if (predicate(value, i)) {
return value;
}
}
return undefined;
}
|
javascript
|
{
"resource": ""
}
|
q1464
|
findMap
|
train
|
function findMap(array, callback) {
for (var i = 0, len = array.length; i < len; i++) {
var result = callback(array[i], i);
if (result) {
return result;
}
}
Debug.fail();
}
|
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];
if (f(item)) {
result.push(item);
}
i++;
}
return result;
}
}
return array;
}
|
javascript
|
{
"resource": ""
}
|
q1466
|
getOwnKeys
|
train
|
function getOwnKeys(map) {
var keys = [];
for (var key in map)
if (hasOwnProperty.call(map, key)) {
keys.push(key);
}
return keys;
}
|
javascript
|
{
"resource": ""
}
|
q1467
|
reduceProperties
|
train
|
function reduceProperties(map, callback, initial) {
var result = initial;
for (var key in map) {
result = callback(result, map[key], String(key));
}
return result;
}
|
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;
}
for (var key in right)
if (hasOwnProperty.call(right, key)) {
if (!hasOwnProperty.call(left, key))
return false;
}
return true;
}
|
javascript
|
{
"resource": ""
}
|
q1469
|
removeTrailingDirectorySeparator
|
train
|
function removeTrailingDirectorySeparator(path) {
if (path.charAt(path.length - 1) === ts.directorySeparator) {
return path.substr(0, path.length - 1);
}
return path;
}
|
javascript
|
{
"resource": ""
}
|
q1470
|
ensureTrailingDirectorySeparator
|
train
|
function ensureTrailingDirectorySeparator(path) {
if (path.charAt(path.length - 1) !== ts.directorySeparator) {
return path + ts.directorySeparator;
}
return path;
}
|
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 canonical path representations.
includeBasePaths.sort(useCaseSensitiveFileNames ? compareStrings : compareStringsCaseInsensitive);
// Iterate over each include base path and include unique base paths that are not a
// subpath of an existing base path
include: for (var i = 0; i < includeBasePaths.length; i++) {
var includeBasePath = includeBasePaths[i];
for (var j = 0; j < basePaths.length; j++) {
if (containsPath(basePaths[j], includeBasePath, path, !useCaseSensitiveFileNames)) {
continue include;
}
}
basePaths.push(includeBasePath);
}
}
return basePaths;
}
|
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 */ ||
ch === 5760 /* ogham */ ||
ch >= 8192 /* enQuad */ && ch <= 8203 /* zeroWidthSpace */ ||
ch === 8239 /* narrowNoBreakSpace */ ||
ch === 8287 /* mathematicalSpace */ ||
ch === 12288 /* ideographicSpace */ ||
ch === 65279 /* byteOrderMark */;
}
|
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" &&
expression.arguments.length === 1;
return isRequire && (!checkArgumentIsStringLiteral || expression.arguments[0].kind === 9 /* StringLiteral */);
}
|
javascript
|
{
"resource": ""
}
|
q1474
|
isDeclarationOfFunctionExpression
|
train
|
function isDeclarationOfFunctionExpression(s) {
if (s.valueDeclaration && s.valueDeclaration.kind === 218 /* VariableDeclaration */) {
var declaration = s.valueDeclaration;
return declaration.initializer && declaration.initializer.kind === 179 /* FunctionExpression */;
}
return false;
}
|
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)) {
continue;
}
clone[key] = node[key];
}
if (flags !== undefined) {
clone.flags = flags;
}
if (parent !== undefined) {
clone.parent = parent;
}
return clone;
}
|
javascript
|
{
"resource": ""
}
|
q1476
|
cloneEntityName
|
train
|
function cloneEntityName(node, parent) {
var clone = cloneNode(node, node, node.flags, parent);
if (isQualifiedName(clone)) {
var left = clone.left, right = clone.right;
clone.left = cloneEntityName(left, clone);
clone.right = cloneNode(right, right, right.flags, parent);
}
return 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());
var relativePath = ts.getRelativePathToDirectoryOrUrl(dir, filePath, dir, getCanonicalFileName, /*isAbsolutePathAnUrl*/ false);
return ts.removeFileExtension(relativePath);
}
|
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. Make
// sure there is at least one blank line between it and the node. If not, it's not
// a copyright header.
var lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, ts.lastOrUndefined(detachedComments).end);
var nodeLine = getLineOfLocalPositionFromLineMap(lineMap, ts.skipTrivia(text, node.pos));
if (nodeLine >= lastCommentLine + 2) {
// Valid detachedComments
emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments);
emitComments(text, lineMap, writer, detachedComments, /*trailingSeparator*/ true, newLine, writeComment);
currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts.lastOrUndefined(detachedComments).end };
}
}
}
return currentDetachedCommentInfo;
function isPinnedComment(comment) {
return text.charCodeAt(comment.pos + 1) === 42 /* asterisk */ &&
text.charCodeAt(comment.pos + 2) === 33 /* exclamation */;
}
}
|
javascript
|
{
"resource": ""
}
|
q1479
|
tryExtractTypeScriptExtension
|
train
|
function tryExtractTypeScriptExtension(fileName) {
return ts.find(ts.supportedTypescriptExtensionsForExtractExtension, function (extension) { return ts.fileExtensionIs(fileName, extension); });
}
|
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;
byte3 = (charCodes[i + 1] & 15) << 2 | charCodes[i + 2] >> 6;
byte4 = charCodes[i + 2] & 63;
// We are out of characters in the input, set the extra
// digits to 64 (padding character).
if (i + 1 >= length) {
byte3 = byte4 = 64;
}
else if (i + 2 >= length) {
byte4 = 64;
}
// Write to the output
result += base64Digits.charAt(byte1) + base64Digits.charAt(byte2) + base64Digits.charAt(byte3) + base64Digits.charAt(byte4);
i += 3;
}
return result;
}
|
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 | /----
// | /----
// | /----
// ------------------------------------------------------------$------------------------------------------
// . | \
// . | \
// T2 . | \
// . | \
// . | \
// ----------------------------------------------------------------------*--------------------------------
//
// In other words (in this case), we're recognizing that the second edit happened after where the first edit
// ended with a delta of 20 characters (60 - 40). Thus, if we go back in time to where the first edit started
// that's the same as if we started at char 80 instead of 60.
//
// As it so happens, the same logic applies if the second edit precedes the first edit. In that case rather
// than pushing the first edit forward to match the second, we'll push the second edit forward to match the
// first.
//
// In this case that means we have { oldStart: 10, oldEnd: 80, newEnd: 70 } or, in TextChangeRange
// semantics: { { start: 10, length: 70 }, newLength: 60 }
//
// The math then works out as follows.
// If we have { oldStart1, oldEnd1, newEnd1 } and { oldStart2, oldEnd2, newEnd2 } then we can compute the
// final result like so:
//
// {
// oldStart3: Min(oldStart1, oldStart2),
// oldEnd3 : Max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)),
// newEnd3 : Max(newEnd2, newEnd2 + (newEnd1 - oldEnd2))
// }
var oldStart1 = oldStartN;
var oldEnd1 = oldEndN;
var newEnd1 = newEndN;
var oldStart2 = nextChange.span.start;
var oldEnd2 = textSpanEnd(nextChange.span);
var newEnd2 = oldStart2 + nextChange.newLength;
oldStartN = Math.min(oldStart1, oldStart2);
oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1));
newEndN = Math.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2));
}
return createTextChangeRange(createTextSpanFromBounds(oldStartN, oldEndN), /*newLength:*/ newEndN - oldStartN);
}
|
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
// considered a keyword and is not an identifier.
if (token() === 119 /* AwaitKeyword */ && inAwaitContext()) {
return false;
}
return token() > 105 /* LastReservedWord */;
}
|
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();
case 10 /* ArrayBindingElements */:
return token() === 24 /* CommaToken */ || token() === 22 /* DotDotDotToken */ || isIdentifierOrPattern();
case 17 /* TypeParameters */:
return isIdentifier();
case 11 /* ArgumentExpressions */:
case 15 /* ArrayLiteralMembers */:
return token() === 24 /* CommaToken */ || token() === 22 /* DotDotDotToken */ || isStartOfExpression();
case 16 /* Parameters */:
return isStartOfParameter();
case 18 /* TypeArguments */:
case 19 /* TupleElementTypes */:
return token() === 24 /* CommaToken */ || isStartOfType();
case 20 /* HeritageClauses */:
return isHeritageClause();
case 21 /* ImportOrExportSpecifiers */:
return ts.tokenIsIdentifierOrKeyword(token());
case 13 /* JsxAttributes */:
return ts.tokenIsIdentifierOrKeyword(token()) || token() === 15 /* OpenBraceToken */;
case 14 /* JsxChildren */:
return true;
case 22 /* JSDocFunctionParameters */:
case 23 /* JSDocTypeArguments */:
case 25 /* JSDocTupleTypes */:
return JSDocParser.isJSDocType();
case 24 /* JSDocRecordMembers */:
return isSimplePropertyName();
}
ts.Debug.fail("Non-exhaustive case in 'isListElement'.");
}
|
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)) {
return true;
}
}
}
return false;
}
|
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;
}
if (abortParsingListOrMoveToNextToken(kind)) {
break;
}
}
result.end = getNodeEnd();
parsingContext = saveParsingContext;
return result;
}
|
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;
}
if (isListTerminator(kind)) {
break;
}
if (abortParsingListOrMoveToNextToken(kind)) {
break;
}
}
// Recording the trailing comma is deliberately done after the previous
// loop, and not just if we see a list terminator. This is because the list
// may have ended incorrectly, but it is still important to know if there
// was a trailing comma.
// Check if the last token was a comma.
if (commaStart >= 0) {
// Always preserve a trailing comma by marking it on the NodeArray
result.hasTrailingComma = true;
}
result.end = getNodeEnd();
parsingContext = saveParsingContext;
return result;
}
|
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]
*/
var unaryOperator = token();
var simpleUnaryExpression = parseSimpleUnaryExpression();
if (token() === 38 /* AsteriskAsteriskToken */) {
var start = ts.skipTrivia(sourceText, simpleUnaryExpression.pos);
if (simpleUnaryExpression.kind === 177 /* TypeAssertionExpression */) {
parseErrorAtPosition(start, simpleUnaryExpression.end - start, ts.Diagnostics.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses);
}
else {
parseErrorAtPosition(start, simpleUnaryExpression.end - start, ts.Diagnostics.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses, ts.tokenToString(unaryOperator));
}
}
return simpleUnaryExpression;
}
|
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();
ts.Debug.assert(ts.isLeftHandSideExpression(expression));
if ((token() === 41 /* PlusPlusToken */ || token() === 42 /* MinusMinusToken */) && !scanner.hasPrecedingLineBreak()) {
var node = createNode(186 /* PostfixUnaryExpression */, expression.pos);
node.operand = expression;
node.operator = token();
nextToken();
return finishNode(node);
}
return expression;
}
|
javascript
|
{
"resource": ""
}
|
q1489
|
parseEnumMember
|
train
|
function parseEnumMember() {
var node = createNode(255 /* EnumMember */, scanner.getStartPos());
node.name = parsePropertyName();
node.initializer = allowInAnd(parseNonParameterInitializer);
return finishNode(node);
}
|
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) {
ts.trace(state.host, ts.Diagnostics.File_0_does_not_exist, fileName);
}
failedLookupLocation.push(fileName);
return undefined;
}
}
|
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);
}
}
return ts.forEach(extensions, function (ext) {
return !(state.skipTsx && ts.isJsxOrTsxExtension(ext)) && tryFile(candidate + ext, failedLookupLocation, onlyRecordFailures, state);
});
}
|
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 */:
switch (ts.getSpecialPropertyAssignmentKind(node)) {
case 2 /* ModuleExports */:
// module.exports = ...
return "export=";
case 1 /* ExportsProperty */:
case 4 /* ThisProperty */:
// exports.x = ... or this.y = ...
return node.left.name.text;
case 3 /* PrototypeProperty */:
// className.prototype.methodName = ...
return node.left.expression.name.text;
}
ts.Debug.fail("Unknown binary declaration kind");
break;
case 220 /* FunctionDeclaration */:
case 221 /* ClassDeclaration */:
return node.flags & 512 /* Default */ ? "default" : undefined;
case 269 /* JSDocFunctionType */:
return ts.isJSDocConstructSignature(node) ? "__new" : "__call";
case 142 /* Parameter */:
// Parameters with names are handled at the top of this function. Parameters
// without names can only come from JSDocFunctionTypes.
ts.Debug.assert(node.parent.kind === 269 /* JSDocFunctionType */);
var functionType = node.parent;
var index = ts.indexOf(functionType.parameters, node);
return "p" + index;
case 279 /* JSDocTypedefTag */:
var parentNode = node.parent && node.parent.parent;
var nameFromParentNode = void 0;
if (parentNode && parentNode.kind === 200 /* VariableStatement */) {
if (parentNode.declarationList.declarations.length > 0) {
var nameIdentifier = parentNode.declarationList.declarations[0].name;
if (nameIdentifier.kind === 69 /* Identifier */) {
nameFromParentNode = nameIdentifier.text;
}
}
}
return nameFromParentNode;
}
}
|
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
// in the symbol table, or we conflicted with an existing symbol, then just add this
// node as the sole declaration of the new symbol.
//
// Otherwise, we'll be merging into a compatible existing symbol (for example when
// you have multiple 'vars' with the same name in the same container). In this case
// just add this node into the declarations list of the symbol.
symbol = symbolTable[name] || (symbolTable[name] = createSymbol(0 /* None */, name));
if (name && (includes & 788448 /* Classifiable */)) {
classifiableNames[name] = name;
}
if (symbol.flags & excludes) {
if (symbol.isReplaceableByMethod) {
// Javascript constructor-declared symbols can be discarded in favor of
// prototype symbols like methods.
symbol = symbolTable[name] = createSymbol(0 /* None */, name);
}
else {
if (node.name) {
node.name.parent = node;
}
// Report errors every position with duplicate declaration
// Report errors on previous encountered declarations
var message_1 = symbol.flags & 2 /* BlockScopedVariable */
? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0
: ts.Diagnostics.Duplicate_identifier_0;
ts.forEach(symbol.declarations, function (declaration) {
if (declaration.flags & 512 /* Default */) {
message_1 = ts.Diagnostics.A_module_cannot_have_multiple_default_exports;
}
});
ts.forEach(symbol.declarations, function (declaration) {
file.bindDiagnostics.push(ts.createDiagnosticForNode(declaration.name || declaration, message_1, getDisplayName(declaration)));
});
file.bindDiagnostics.push(ts.createDiagnosticForNode(node.name || node, message_1, getDisplayName(node)));
symbol = createSymbol(0 /* None */, name);
}
}
}
addDeclarationToSymbol(symbol, node, includes);
symbol.parent = parent;
return symbol;
}
|
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;
bindChildren(node);
// Reset all reachability check related flags on node (for incremental scenarios)
// Reset all emit helper flags on node (for incremental scenarios)
node.flags &= ~4030464 /* ReachabilityAndEmitFlags */;
if (!(currentFlow.flags & 1 /* Unreachable */) && containerFlags & 8 /* IsFunctionLike */ && ts.nodeIsPresent(node.body)) {
node.flags |= 32768 /* HasImplicitReturn */;
if (hasExplicitReturn)
node.flags |= 65536 /* HasExplicitReturn */;
}
if (node.kind === 256 /* SourceFile */) {
node.flags |= emitFlags;
}
if (isIIFE) {
addAntecedent(currentReturnTarget, currentFlow);
currentFlow = finishFlowLabel(currentReturnTarget);
}
else {
currentFlow = saveCurrentFlow;
}
currentBreakTarget = saveBreakTarget;
currentContinueTarget = saveContinueTarget;
currentReturnTarget = saveReturnTarget;
activeLabels = saveActiveLabels;
hasExplicitReturn = saveHasExplicitReturn;
}
else if (containerFlags & 64 /* IsInterface */) {
seenThisKeyword = false;
bindChildren(node);
node.flags = seenThisKeyword ? node.flags | 16384 /* ContainsThis */ : node.flags & ~16384 /* ContainsThis */;
}
else {
bindChildren(node);
}
container = saveContainer;
blockScopeContainer = savedBlockScopeContainer;
}
|
javascript
|
{
"resource": ""
}
|
q1495
|
checkStrictModeIdentifier
|
train
|
function checkStrictModeIdentifier(node) {
if (inStrictMode &&
node.originalKeywordKind >= 106 /* FirstFutureReservedWord */ &&
node.originalKeywordKind <= 114 /* LastFutureReservedWord */ &&
!ts.isIdentifierName(node) &&
!ts.isInAmbientContext(node)) {
// Report error only if there are no parse errors in file
if (!file.parseDiagnostics.length) {
file.bindDiagnostics.push(ts.createDiagnosticForNode(node, getStrictModeIdentifierMessage(node), ts.declarationNameToString(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 */);
if (parameterSymbol && propertySymbol) {
return [parameterSymbol, propertySymbol];
}
ts.Debug.fail("There should exist two symbols, one as property declaration and one as parameter declaration");
}
|
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 */:
ts.Debug.assert(ts.isEntityNameExpression(node.expression));
return node.expression;
default:
return undefined;
}
}
|
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)) {
entityName = entityName.parent;
}
// Check for case 1 and 3 in the above example
if (entityName.kind === 69 /* Identifier */ || entityName.parent.kind === 139 /* QualifiedName */) {
return resolveEntityName(entityName, 1920 /* Namespace */, /*ignoreErrors*/ false, dontResolveAlias);
}
else {
// Case 2 in above example
// entityName.kind could be a QualifiedName or a Missing identifier
ts.Debug.assert(entityName.parent.kind === 229 /* ImportEqualsDeclaration */);
return resolveEntityName(entityName, 107455 /* Value */ | 793064 /* Type */ | 1920 /* Namespace */, /*ignoreErrors*/ false, dontResolveAlias);
}
}
|
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)
};
}
}
else if (lookupTable && exportNode && id !== "default" && target[id] && resolveSymbol(target[id]) !== resolveSymbol(source[id])) {
if (!lookupTable[id].exportsWithDuplicate) {
lookupTable[id].exportsWithDuplicate = [exportNode];
}
else {
lookupTable[id].exportsWithDuplicate.push(exportNode);
}
}
}
}
|
javascript
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.