file_path stringlengths 3 280 | file_language stringclasses 66 values | content stringlengths 1 1.04M | repo_name stringlengths 5 92 | repo_stars int64 0 154k | repo_description stringlengths 0 402 | repo_primary_language stringclasses 108 values | developer_username stringlengths 1 25 | developer_name stringlengths 0 30 | developer_company stringlengths 0 82 |
|---|---|---|---|---|---|---|---|---|---|
crates/swc_ecma_transforms_base/src/helpers/_async_to_generator.js | JavaScript | function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _async_to_generator(fn) {
return function() {
var self = this, args = arguments;
return new Promise(function(resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_await_async_generator.js | JavaScript | function _await_async_generator(value) {
return new _await_value(value);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_await_value.js | JavaScript | function _await_value(value) {
this.wrapped = value;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_call_super.js | JavaScript | function _call_super(_this, derived, args) {
// Super
derived = _get_prototype_of(derived);
return _possible_constructor_return(
_this,
_is_native_reflect_construct()
// NOTE: This doesn't work if this.__proto__.constructor has been modified.
? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor)
: derived.apply(_this, args)
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_check_private_redeclaration.js | JavaScript | function _check_private_redeclaration(obj, privateCollection) {
if (privateCollection.has(obj)) {
throw new TypeError("Cannot initialize the same private elements twice on an object");
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_apply_descriptor_destructure.js | JavaScript | function _class_apply_descriptor_destructure(receiver, descriptor) {
if (descriptor.set) {
if (!("__destrObj" in descriptor)) {
descriptor.__destrObj = {
set value(v) {
descriptor.set.call(receiver, v);
}
};
}
return descriptor.__destrObj;
} else {
if (!descriptor.writable) {
// This should only throw in strict mode, but class bodies are
// always strict and private fields can only be used inside
// class bodies.
throw new TypeError("attempted to set read only private field");
}
return descriptor;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_apply_descriptor_get.js | JavaScript | function _class_apply_descriptor_get(receiver, descriptor) {
if (descriptor.get) {
return descriptor.get.call(receiver);
}
return descriptor.value;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_apply_descriptor_set.js | JavaScript | function _class_apply_descriptor_set(receiver, descriptor, value) {
if (descriptor.set) {
descriptor.set.call(receiver, value);
} else {
if (!descriptor.writable) {
// This should only throw in strict mode, but class bodies are
// always strict and private fields can only be used inside
// class bodies.
throw new TypeError("attempted to set read only private field");
}
descriptor.value = value;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_apply_descriptor_update.js | JavaScript | function _class_apply_descriptor_update(receiver, descriptor) {
if (descriptor.set) {
if (!descriptor.get) {
throw new TypeError("attempted to read set only private field");
}
if (!("__destrWrapper" in descriptor)) {
descriptor.__destrWrapper = {
set value(v) {
descriptor.set.call(receiver, v);
},
get value() {
return descriptor.get.call(receiver);
}
};
}
return descriptor.__destrWrapper;
} else {
if (!descriptor.writable) {
// This should only throw in strict mode, but class bodies are
// always strict and private fields can only be used inside
// class bodies.
throw new TypeError("attempted to set read only private field");
}
return descriptor;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_call_check.js | JavaScript | function _class_call_check(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_check_private_static_access.js | JavaScript | function _class_check_private_static_access(receiver, classConstructor) {
if (receiver !== classConstructor) {
throw new TypeError("Private static access of wrong provenance");
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_check_private_static_field_descriptor.js | JavaScript | function _class_check_private_static_field_descriptor(descriptor, action) {
if (descriptor === undefined) {
throw new TypeError("attempted to " + action + " private static field before its declaration");
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_extract_field_descriptor.js | JavaScript | function _class_extract_field_descriptor(receiver, privateMap, action) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to " + action + " private field on non-instance");
}
return privateMap.get(receiver);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_name_tdz_error.js | JavaScript | function _class_name_tdz_error(name) {
throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys.");
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_private_field_destructure.js | JavaScript | function _class_private_field_destructure(receiver, privateMap) {
var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
return _class_apply_descriptor_destructure(receiver, descriptor);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_private_field_get.js | JavaScript | function _class_private_field_get(receiver, privateMap) {
var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
return _class_apply_descriptor_get(receiver, descriptor);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_private_field_init.js | JavaScript | function _class_private_field_init(obj, privateMap, value) {
_check_private_redeclaration(obj, privateMap);
privateMap.set(obj, value);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_private_field_loose_base.js | JavaScript | function _class_private_field_loose_base(receiver, privateKey) {
if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
throw new TypeError("attempted to use private field on non-instance");
}
return receiver;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_private_field_loose_key.js | JavaScript | var id = 0;
function _class_private_field_loose_key(name) {
return "__private_" + id++ + "_" + name;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_private_field_set.js | JavaScript | function _class_private_field_set(receiver, privateMap, value) {
var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
_class_apply_descriptor_set(receiver, descriptor, value);
return value;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_private_field_update.js | JavaScript | function _class_private_field_update(receiver, privateMap) {
var descriptor = _class_extract_field_descriptor(receiver, privateMap, "update");
return _class_apply_descriptor_update(receiver, descriptor);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_private_method_get.js | JavaScript | function _class_private_method_get(receiver, privateSet, fn) {
if (!privateSet.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return fn;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_private_method_init.js | JavaScript | function _class_private_method_init(obj, privateSet) {
_check_private_redeclaration(obj, privateSet);
privateSet.add(obj);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_private_method_set.js | JavaScript | function _class_private_method_set() {
throw new TypeError("attempted to reassign private method");
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_static_private_field_destructure.js | JavaScript | function _class_static_private_field_destructure(receiver, classConstructor, descriptor) {
_class_check_private_static_access(receiver, classConstructor);
_class_check_private_static_field_descriptor(descriptor, "set");
return _class_apply_descriptor_destructure(receiver, descriptor);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_static_private_field_spec_get.js | JavaScript | function _class_static_private_field_spec_get(receiver, classConstructor, descriptor) {
_class_check_private_static_access(receiver, classConstructor);
_class_check_private_static_field_descriptor(descriptor, "get");
return _class_apply_descriptor_get(receiver, descriptor);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_static_private_field_spec_set.js | JavaScript | function _class_static_private_field_spec_set(receiver, classConstructor, descriptor, value) {
_class_check_private_static_access(receiver, classConstructor);
_class_check_private_static_field_descriptor(descriptor, "set");
_class_apply_descriptor_set(receiver, descriptor, value);
return value;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_static_private_field_update.js | JavaScript | function _class_static_private_field_update(receiver, classConstructor, descriptor) {
_class_check_private_static_access(receiver, classConstructor);
_class_check_private_static_field_descriptor(descriptor, "update");
return _class_apply_descriptor_update(receiver, descriptor);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_class_static_private_method_get.js | JavaScript | function _class_static_private_method_get(receiver, classConstructor, method) {
_class_check_private_static_access(receiver, classConstructor);
return method;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_construct.js | JavaScript | function _construct(Parent, args, Class) {
if (_is_native_reflect_construct()) {
_construct = Reflect.construct;
} else {
_construct = function construct(Parent, args, Class) {
var a = [null];
a.push.apply(a, args);
var Constructor = Function.bind.apply(Parent, a);
var instance = new Constructor();
if (Class) _set_prototype_of(instance, Class.prototype);
return instance;
};
}
return _construct.apply(null, arguments);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_create_class.js | JavaScript | function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _create_class(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_create_for_of_iterator_helper_loose.js | JavaScript | function _create_for_of_iterator_helper_loose(o, allowArrayLike) {
var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
if (it) return (it = it.call(o)).next.bind(it);
// Fallback for engines without symbol support
if (Array.isArray(o) || (it = _unsupported_iterable_to_array(o)) || allowArrayLike && o && typeof o.length === "number") {
if (it) o = it;
var i = 0;
return function() {
if (i >= o.length) {
return { done: true };
}
return { done: false, value: o[i++] };
};
}
throw new TypeError(
"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_create_super.js | JavaScript | function _create_super(Derived) {
var hasNativeReflectConstruct = _is_native_reflect_construct();
return function _createSuperInternal() {
var Super = _get_prototype_of(Derived), result;
if (hasNativeReflectConstruct) {
var NewTarget = _get_prototype_of(this).constructor;
result = Reflect.construct(Super, arguments, NewTarget);
} else {
result = Super.apply(this, arguments);
}
return _possible_constructor_return(this, result);
};
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_decorate.js | JavaScript | function _decorate(decorators, factory, superClass) {
var r = factory(function initialize(O) {
_initializeInstanceElements(O, decorated.elements);
}, superClass);
var decorated = _decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators);
_initializeClassElements(r.F, decorated.elements);
return _runClassFinishers(r.F, decorated.finishers);
}
function _createElementDescriptor(def) {
var key = _to_property_key(def.key);
var descriptor;
if (def.kind === "method") {
descriptor = { value: def.value, writable: true, configurable: true, enumerable: false };
Object.defineProperty(def.value, "name", { value: _type_of(key) === "symbol" ? "" : key, configurable: true });
} else if (def.kind === "get") {
descriptor = { get: def.value, configurable: true, enumerable: false };
} else if (def.kind === "set") {
descriptor = { set: def.value, configurable: true, enumerable: false };
} else if (def.kind === "field") {
descriptor = { configurable: true, writable: true, enumerable: true };
}
var element = {
kind: def.kind === "field" ? "field" : "method",
key: key,
placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype",
descriptor: descriptor
};
if (def.decorators) element.decorators = def.decorators;
if (def.kind === "field") element.initializer = def.value;
return element;
}
function _coalesceGetterSetter(element, other) {
if (element.descriptor.get !== undefined) {
other.descriptor.get = element.descriptor.get;
} else {
other.descriptor.set = element.descriptor.set;
}
}
function _coalesceClassElements(elements) {
var newElements = [];
var isSameElement = function isSameElement(other) {
return other.kind === "method" && other.key === element.key && other.placement === element.placement;
};
for (var i = 0; i < elements.length; i++) {
var element = elements[i];
var other;
if (element.kind === "method" && (other = newElements.find(isSameElement))) {
if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) {
if (_hasDecorators(element) || _hasDecorators(other)) {
throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated.");
}
other.descriptor = element.descriptor;
} else {
if (_hasDecorators(element)) {
if (_hasDecorators(other)) {
throw new ReferenceError(
"Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."
);
}
other.decorators = element.decorators;
}
_coalesceGetterSetter(element, other);
}
} else {
newElements.push(element);
}
}
return newElements;
}
function _hasDecorators(element) {
return element.decorators && element.decorators.length;
}
function _isDataDescriptor(desc) {
return desc !== undefined && !(desc.value === undefined && desc.writable === undefined);
}
function _initializeClassElements(F, elements) {
var proto = F.prototype;
["method", "field"].forEach(function(kind) {
elements.forEach(function(element) {
var placement = element.placement;
if (element.kind === kind && (placement === "static" || placement === "prototype")) {
var receiver = placement === "static" ? F : proto;
_defineClassElement(receiver, element);
}
});
});
}
function _initializeInstanceElements(O, elements) {
["method", "field"].forEach(function(kind) {
elements.forEach(function(element) {
if (element.kind === kind && element.placement === "own") {
_defineClassElement(O, element);
}
});
});
}
function _defineClassElement(receiver, element) {
var descriptor = element.descriptor;
if (element.kind === "field") {
var initializer = element.initializer;
descriptor = {
enumerable: descriptor.enumerable,
writable: descriptor.writable,
configurable: descriptor.configurable,
value: initializer === void 0 ? void 0 : initializer.call(receiver)
};
}
Object.defineProperty(receiver, element.key, descriptor);
}
function _decorateClass(elements, decorators) {
var newElements = [];
var finishers = [];
var placements = { static: [], prototype: [], own: [] };
elements.forEach(function(element) {
_addElementPlacement(element, placements);
});
elements.forEach(function(element) {
if (!_hasDecorators(element)) return newElements.push(element);
var elementFinishersExtras = _decorateElement(element, placements);
newElements.push(elementFinishersExtras.element);
newElements.push.apply(newElements, elementFinishersExtras.extras);
finishers.push.apply(finishers, elementFinishersExtras.finishers);
});
if (!decorators) {
return { elements: newElements, finishers: finishers };
}
var result = _decorateConstructor(newElements, decorators);
finishers.push.apply(finishers, result.finishers);
result.finishers = finishers;
return result;
}
function _addElementPlacement(element, placements, silent) {
var keys = placements[element.placement];
if (!silent && keys.indexOf(element.key) !== -1) {
throw new TypeError("Duplicated element (" + element.key + ")");
}
keys.push(element.key);
}
function _decorateElement(element, placements) {
var extras = [];
var finishers = [];
for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) {
var keys = placements[element.placement];
keys.splice(keys.indexOf(element.key), 1);
var elementObject = _fromElementDescriptor(element);
var elementFinisherExtras = _toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject);
element = elementFinisherExtras.element;
_addElementPlacement(element, placements);
if (elementFinisherExtras.finisher) {
finishers.push(elementFinisherExtras.finisher);
}
var newExtras = elementFinisherExtras.extras;
if (newExtras) {
for (var j = 0; j < newExtras.length; j++) {
_addElementPlacement(newExtras[j], placements);
}
extras.push.apply(extras, newExtras);
}
}
return { element: element, finishers: finishers, extras: extras };
}
function _decorateConstructor(elements, decorators) {
var finishers = [];
for (var i = decorators.length - 1; i >= 0; i--) {
var obj = _fromClassDescriptor(elements);
var elementsAndFinisher = _toClassDescriptor((0, decorators[i])(obj) || obj);
if (elementsAndFinisher.finisher !== undefined) {
finishers.push(elementsAndFinisher.finisher);
}
if (elementsAndFinisher.elements !== undefined) {
elements = elementsAndFinisher.elements;
for (var j = 0; j < elements.length - 1; j++) {
for (var k = j + 1; k < elements.length; k++) {
if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) {
throw new TypeError("Duplicated element (" + elements[j].key + ")");
}
}
}
}
}
return { elements: elements, finishers: finishers };
}
function _fromElementDescriptor(element) {
var obj = { kind: element.kind, key: element.key, placement: element.placement, descriptor: element.descriptor };
var desc = { value: "Descriptor", configurable: true };
Object.defineProperty(obj, Symbol.toStringTag, desc);
if (element.kind === "field") obj.initializer = element.initializer;
return obj;
}
function _toElementDescriptors(elementObjects) {
if (elementObjects === undefined) return;
return _to_array(elementObjects).map(function(elementObject) {
var element = _toElementDescriptor(elementObject);
_disallowProperty(elementObject, "finisher", "An element descriptor");
_disallowProperty(elementObject, "extras", "An element descriptor");
return element;
});
}
function _toElementDescriptor(elementObject) {
var kind = String(elementObject.kind);
if (kind !== "method" && kind !== "field") {
throw new TypeError(
"An element descriptor's .kind property must be either \"method\" or"
+ " \"field\", but a decorator created an element descriptor with" + " .kind \"" + kind + "\""
);
}
var key = _to_property_key(elementObject.key);
var placement = String(elementObject.placement);
if (placement !== "static" && placement !== "prototype" && placement !== "own") {
throw new TypeError(
"An element descriptor's .placement property must be one of \"static\","
+ " \"prototype\" or \"own\", but a decorator created an element descriptor" + " with .placement \"" + placement + "\""
);
}
var descriptor = elementObject.descriptor;
_disallowProperty(elementObject, "elements", "An element descriptor");
var element = { kind: kind, key: key, placement: placement, descriptor: Object.assign({}, descriptor) };
if (kind !== "field") {
_disallowProperty(elementObject, "initializer", "A method descriptor");
} else {
_disallowProperty(descriptor, "get", "The property descriptor of a field descriptor");
_disallowProperty(descriptor, "set", "The property descriptor of a field descriptor");
_disallowProperty(descriptor, "value", "The property descriptor of a field descriptor");
element.initializer = elementObject.initializer;
}
return element;
}
function _toElementFinisherExtras(elementObject) {
var element = _toElementDescriptor(elementObject);
var finisher = _optionalCallableProperty(elementObject, "finisher");
var extras = _toElementDescriptors(elementObject.extras);
return { element: element, finisher: finisher, extras: extras };
}
function _fromClassDescriptor(elements) {
var obj = { kind: "class", elements: elements.map(_fromElementDescriptor) };
var desc = { value: "Descriptor", configurable: true };
Object.defineProperty(obj, Symbol.toStringTag, desc);
return obj;
}
function _toClassDescriptor(obj) {
var kind = String(obj.kind);
if (kind !== "class") {
throw new TypeError(
"A class descriptor's .kind property must be \"class\", but a decorator" + " created a class descriptor with .kind \"" + kind
+ "\""
);
}
_disallowProperty(obj, "key", "A class descriptor");
_disallowProperty(obj, "placement", "A class descriptor");
_disallowProperty(obj, "descriptor", "A class descriptor");
_disallowProperty(obj, "initializer", "A class descriptor");
_disallowProperty(obj, "extras", "A class descriptor");
var finisher = _optionalCallableProperty(obj, "finisher");
var elements = _toElementDescriptors(obj.elements);
return { elements: elements, finisher: finisher };
}
function _disallowProperty(obj, name, objectType) {
if (obj[name] !== undefined) {
throw new TypeError(objectType + " can't have a ." + name + " property.");
}
}
function _optionalCallableProperty(obj, name) {
var value = obj[name];
if (value !== undefined && typeof value !== "function") {
throw new TypeError("Expected '" + name + "' to be a function");
}
return value;
}
function _runClassFinishers(constructor, finishers) {
for (var i = 0; i < finishers.length; i++) {
var newConstructor = (0, finishers[i])(constructor);
if (newConstructor !== undefined) {
if (typeof newConstructor !== "function") {
throw new TypeError("Finishers must return a constructor.");
}
constructor = newConstructor;
}
}
return constructor;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_defaults.js | JavaScript | function _defaults(obj, defaults) {
var keys = Object.getOwnPropertyNames(defaults);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var value = Object.getOwnPropertyDescriptor(defaults, key);
if (value && value.configurable && obj[key] === undefined) {
Object.defineProperty(obj, key, value);
}
}
return obj;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_define_enumerable_properties.js | JavaScript | function _define_enumerable_properties(obj, descs) {
for (var key in descs) {
var desc = descs[key];
desc.configurable = desc.enumerable = true;
if ("value" in desc) desc.writable = true;
Object.defineProperty(obj, key, desc);
}
if (Object.getOwnPropertySymbols) {
var objectSymbols = Object.getOwnPropertySymbols(descs);
for (var i = 0; i < objectSymbols.length; i++) {
var sym = objectSymbols[i];
var desc = descs[sym];
desc.configurable = desc.enumerable = true;
if ("value" in desc) desc.writable = true;
Object.defineProperty(obj, sym, desc);
}
}
return obj;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_define_property.js | JavaScript | function _define_property(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true });
} else {
obj[key] = value;
}
return obj;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_dispose.js | JavaScript | /* @minVersion 7.22.0 */
function dispose_SuppressedError(suppressed, error) {
if (typeof SuppressedError !== "undefined") {
// eslint-disable-next-line no-undef
dispose_SuppressedError = SuppressedError;
} else {
dispose_SuppressedError = function SuppressedError(suppressed, error) {
this.suppressed = suppressed;
this.error = error;
this.stack = new Error().stack;
};
dispose_SuppressedError.prototype = Object.create(Error.prototype, {
constructor: {
value: dispose_SuppressedError,
writable: true,
configurable: true,
},
});
}
return new dispose_SuppressedError(suppressed, error);
}
function _dispose(stack, error, hasError) {
function next() {
while (stack.length > 0) {
try {
var r = stack.pop();
var p = r.d.call(r.v);
if (r.a) return Promise.resolve(p).then(next, err);
} catch (e) {
return err(e);
}
}
if (hasError) throw error;
}
function err(e) {
error = hasError ? new dispose_SuppressedError(e, error) : e;
hasError = true;
return next();
}
return next();
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_export_star.js | JavaScript | function _export_star(from, to) {
Object.keys(from).forEach(function(k) {
if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
Object.defineProperty(to, k, {
enumerable: true,
get: function() {
return from[k];
}
});
}
});
return from;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_extends.js | JavaScript | function _extends() {
_extends = Object.assign || function(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends.apply(this, arguments);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_get.js | JavaScript | function _get(target, property, receiver) {
if (typeof Reflect !== "undefined" && Reflect.get) {
_get = Reflect.get;
} else {
_get = function get(target, property, receiver) {
var base = _super_prop_base(target, property);
if (!base) return;
var desc = Object.getOwnPropertyDescriptor(base, property);
if (desc.get) {
return desc.get.call(receiver || target);
}
return desc.value;
};
}
return _get(target, property, receiver || target);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_get_prototype_of.js | JavaScript | function _get_prototype_of(o) {
_get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _get_prototype_of(o);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_identity.js | JavaScript | function _identity(x) { return x; }
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_inherits.js | JavaScript | function _inherits(subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function");
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: { value: subClass, writable: true, configurable: true }
});
if (superClass) _set_prototype_of(subClass, superClass);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_inherits_loose.js | JavaScript | function _inherits_loose(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
subClass.__proto__ = superClass;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_initializer_define_property.js | JavaScript | function _initializer_define_property(target, property, descriptor, context) {
if (!descriptor) return;
Object.defineProperty(target, property, {
enumerable: descriptor.enumerable,
configurable: descriptor.configurable,
writable: descriptor.writable,
value: descriptor.initializer ? descriptor.initializer.call(context) : void 0
});
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_initializer_warning_helper.js | JavaScript | function _initializer_warning_helper(descriptor, context) {
throw new Error(
"Decorating class property failed. Please ensure that " + "proposal-class-properties is enabled and set to use loose mode. "
+ "To use proposal-class-properties in spec mode with decorators, wait for "
+ "the next major version of decorators in stage 2."
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_instanceof.js | JavaScript | function _instanceof(left, right) {
if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
return !!right[Symbol.hasInstance](left);
} else {
return left instanceof right;
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_interop_require_default.js | JavaScript | function _interop_require_default(obj) {
return obj && obj.__esModule ? obj : { default: obj };
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_interop_require_wildcard.js | JavaScript | function _getRequireWildcardCache(nodeInterop) {
if (typeof WeakMap !== "function") return null;
var cacheBabelInterop = new WeakMap();
var cacheNodeInterop = new WeakMap();
return (_getRequireWildcardCache = function(nodeInterop) {
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
})(nodeInterop);
}
function _interop_require_wildcard(obj, nodeInterop) {
if (!nodeInterop && obj && obj.__esModule) {
return obj;
}
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
return { default: obj };
}
var cache = _getRequireWildcardCache(nodeInterop);
if (cache && cache.has(obj)) {
return cache.get(obj);
}
var newObj = { __proto__: null };
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
for (var key in obj) {
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
if (desc && (desc.get || desc.set)) {
Object.defineProperty(newObj, key, desc);
} else {
newObj[key] = obj[key];
}
}
}
newObj.default = obj;
if (cache) {
cache.set(obj, newObj);
}
return newObj;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_is_native_function.js | JavaScript | function _is_native_function(fn) {
return Function.toString.call(fn).indexOf("[native code]") !== -1;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_is_native_reflect_construct.js | JavaScript | function _is_native_reflect_construct() {
// Since Reflect.construct can't be properly polyfilled, some
// implementations (e.g. core-js@2) don't set the correct internal slots.
// Those polyfills don't allow us to subclass built-ins, so we need to
// use our fallback implementation.
try {
// If the internal slots aren't set, this throws an error similar to
// TypeError: this is not a Boolean object.
var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
} catch (_) {}
return (_is_native_reflect_construct = function() {
return !!result;
})();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_iterable_to_array.js | JavaScript | function _iterable_to_array(iter) {
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_iterable_to_array_limit.js | JavaScript | function _iterable_to_array_limit(arr, i) {
var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
if (_i == null) return;
var _arr = [];
var _n = true;
var _d = false;
var _s, _e;
try {
for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
_arr.push(_s.value);
if (i && _arr.length === i) break;
}
} catch (err) {
_d = true;
_e = err;
} finally {
try {
if (!_n && _i["return"] != null) _i["return"]();
} finally {
if (_d) throw _e;
}
}
return _arr;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_iterable_to_array_limit_loose.js | JavaScript | function _iterable_to_array_limit_loose(arr, i) {
var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]);
if (_i == null) return;
var _arr = [];
for (_i = _i.call(arr), _step; !(_step = _i.next()).done;) {
_arr.push(_step.value);
if (i && _arr.length === i) break;
}
return _arr;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_jsx.js | JavaScript | var REACT_ELEMENT_TYPE;
function _jsx(type, props, key, children) {
if (!REACT_ELEMENT_TYPE) {
REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for && Symbol.for("react.element") || 0xeac7;
}
var defaultProps = type && type.defaultProps;
var childrenLength = arguments.length - 3;
if (!props && childrenLength !== 0) {
props = { children: void 0 };
}
if (props && defaultProps) {
for (var propName in defaultProps) {
if (props[propName] === void 0) {
props[propName] = defaultProps[propName];
}
}
} else if (!props) {
props = defaultProps || {};
}
if (childrenLength === 1) {
props.children = children;
} else if (childrenLength > 1) {
var childArray = new Array(childrenLength);
for (var i = 0; i < childrenLength; i++) {
childArray[i] = arguments[i + 3];
}
props.children = childArray;
}
return { $$typeof: REACT_ELEMENT_TYPE, type: type, key: key === undefined ? null : "" + key, ref: null, props: props, _owner: null };
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_new_arrow_check.js | JavaScript | function _new_arrow_check(innerThis, boundThis) {
if (innerThis !== boundThis) {
throw new TypeError("Cannot instantiate an arrow function");
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_non_iterable_rest.js | JavaScript | function _non_iterable_rest() {
throw new TypeError(
"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_non_iterable_spread.js | JavaScript | function _non_iterable_spread() {
throw new TypeError(
"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_object_destructuring_empty.js | JavaScript | function _object_destructuring_empty(o) {
if (o === null || o === void 0) throw new TypeError("Cannot destructure " + o);
return o;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_object_spread.js | JavaScript | function _object_spread(target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === "function") {
ownKeys = ownKeys.concat(
Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
})
);
}
ownKeys.forEach(function(key) {
_define_property(target, key, source[key]);
});
}
return target;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_object_spread_props.js | JavaScript | function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
if (enumerableOnly) {
symbols = symbols.filter(function(sym) {
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
});
}
keys.push.apply(keys, symbols);
}
return keys;
}
function _object_spread_props(target, source) {
source = source != null ? source : {};
if (Object.getOwnPropertyDescriptors) {
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
} else {
ownKeys(Object(source)).forEach(function(key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_object_without_properties.js | JavaScript | function _object_without_properties(source, excluded) {
if (source == null) return {};
var target = _object_without_properties_loose(source, excluded);
var key, i;
if (Object.getOwnPropertySymbols) {
var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
for (i = 0; i < sourceSymbolKeys.length; i++) {
key = sourceSymbolKeys[i];
if (excluded.indexOf(key) >= 0) continue;
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
target[key] = source[key];
}
}
return target;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_object_without_properties_loose.js | JavaScript | function _object_without_properties_loose(source, excluded) {
if (source == null) return {};
var target = {};
var sourceKeys = Object.keys(source);
var key, i;
for (i = 0; i < sourceKeys.length; i++) {
key = sourceKeys[i];
if (excluded.indexOf(key) >= 0) continue;
target[key] = source[key];
}
return target;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_possible_constructor_return.js | JavaScript | function _possible_constructor_return(self, call) {
if (call && (_type_of(call) === "object" || typeof call === "function")) {
return call;
}
return _assert_this_initialized(self);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_read_only_error.js | JavaScript | function _read_only_error(name) {
throw new TypeError("\"" + name + "\" is read-only");
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_set.js | JavaScript | function set(target, property, value, receiver) {
if (typeof Reflect !== "undefined" && Reflect.set) {
set = Reflect.set;
} else {
set = function set(target, property, value, receiver) {
var base = _super_prop_base(target, property);
var desc;
if (base) {
desc = Object.getOwnPropertyDescriptor(base, property);
if (desc.set) {
desc.set.call(receiver, value);
return true;
} else if (!desc.writable) {
return false;
}
}
desc = Object.getOwnPropertyDescriptor(receiver, property);
if (desc) {
if (!desc.writable) {
return false;
}
desc.value = value;
Object.defineProperty(receiver, property, desc);
} else {
_define_property(receiver, property, value);
}
return true;
};
}
return set(target, property, value, receiver);
}
function _set(target, property, value, receiver, isStrict) {
var s = set(target, property, value, receiver || target);
if (!s && isStrict) {
throw new Error("failed to set property");
}
return value;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_set_prototype_of.js | JavaScript | function _set_prototype_of(o, p) {
_set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _set_prototype_of(o, p);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_skip_first_generator_next.js | JavaScript | function _skip_first_generator_next(fn) {
return function() {
var it = fn.apply(this, arguments);
it.next();
return it;
};
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_sliced_to_array.js | JavaScript | function _sliced_to_array(arr, i) {
return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_sliced_to_array_loose.js | JavaScript | function _sliced_to_array_loose(arr, i) {
return _array_with_holes(arr) || _iterable_to_array_limit_loose(arr, i) || _unsupported_iterable_to_array(arr, i)
|| _non_iterable_rest();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_super_prop_base.js | JavaScript | function _super_prop_base(object, property) {
while (!Object.prototype.hasOwnProperty.call(object, property)) {
object = _get_prototype_of(object);
if (object === null) break;
}
return object;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_tagged_template_literal.js | JavaScript | function _tagged_template_literal(strings, raw) {
if (!raw) {
raw = strings.slice(0);
}
return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } }));
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_tagged_template_literal_loose.js | JavaScript | function _tagged_template_literal_loose(strings, raw) {
if (!raw) {
raw = strings.slice(0);
}
strings.raw = raw;
return strings;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_throw.js | JavaScript | function _throw(e) {
throw e;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_to_array.js | JavaScript | function _to_array(arr) {
return _array_with_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_rest();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_to_consumable_array.js | JavaScript | function _to_consumable_array(arr) {
return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_to_primitive.js | JavaScript | function _to_primitive(input, hint) {
if (_type_of(input) !== "object" || input === null) return input;
var prim = input[Symbol.toPrimitive];
if (prim !== undefined) {
var res = prim.call(input, hint || "default");
if (_type_of(res) !== "object") return res;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return (hint === "string" ? String : Number)(input);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_to_property_key.js | JavaScript | function _to_property_key(arg) {
var key = _to_primitive(arg, "string");
return _type_of(key) === "symbol" ? key : String(key);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_ts_add_disposable_resource.js | JavaScript | function _ts_add_disposable_resource(env, value, async) {
if (value !== null && value !== void 0) {
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
var dispose, inner;
if (async) {
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
dispose = value[Symbol.asyncDispose];
}
if (dispose === void 0) {
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
dispose = value[Symbol.dispose];
if (async) inner = dispose;
}
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
if (inner) dispose = function () { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
env.stack.push({ value: value, dispose: dispose, async: async });
}
else if (async) {
env.stack.push({ async: true });
}
return value;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_ts_decorate.js | JavaScript | function _ts_decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_ts_dispose_resources.js | JavaScript | function _ts_dispose_resources(env) {
var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
var e = new Error(message);
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
};
return (_ts_dispose_resources = function _ts_dispose_resources(env) {
function fail(e) {
env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
env.hasError = true;
}
var r, s = 0;
function next() {
while (r = env.stack.pop()) {
try {
if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
if (r.dispose) {
var result = r.dispose.call(r.value);
if (r.async) return s |= 2, Promise.resolve(result).then(next, function (e) { fail(e); return next(); });
}
else s |= 1;
}
catch (e) {
fail(e);
}
}
if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
if (env.hasError) throw env.error;
}
return next();
})(env);
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_ts_generator.js | JavaScript | function _ts_generator(thisArg, body) {
var f, y, t, g, _ = { label: 0, sent: function () { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] };
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_ts_metadata.js | JavaScript | function _ts_metadata(k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_ts_param.js | JavaScript | function _ts_param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_ts_values.js | JavaScript | function _ts_values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_type_of.js | JavaScript | function _type_of(obj) {
"@swc/helpers - typeof";
return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_unsupported_iterable_to_array.js | JavaScript | function _unsupported_iterable_to_array(o, minLen) {
if (!o) return;
if (typeof o === "string") return _array_like_to_array(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(n);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_update.js | JavaScript | function _update(target, property, receiver, isStrict) {
return {
get _() {
return _get(target, property, receiver);
},
set _(value) {
_set(target, property, value, receiver, isStrict);
}
};
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_using.js | JavaScript | function _using(stack, value, isAwait) {
if (value === null || value === void 0) return value;
if (Object(value) !== value) {
throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
}
// core-js-pure uses Symbol.for for polyfilling well-known symbols
if (isAwait) {
var dispose =
value[Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")];
}
if (dispose === null || dispose === void 0) {
dispose = value[Symbol.dispose || Symbol.for("Symbol.dispose")];
}
if (typeof dispose !== "function") {
throw new TypeError(`Property [Symbol.dispose] is not a function.`);
}
stack.push({ v: value, d: dispose, a: isAwait });
return value;
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_using_ctx.js | JavaScript | function _using_ctx() {
var _disposeSuppressedError =
typeof SuppressedError === "function"
? // eslint-disable-next-line no-undef
SuppressedError
: (function (error, suppressed) {
var err = new Error();
err.name = "SuppressedError";
err.suppressed = suppressed;
err.error = error;
return err;
}),
empty = {},
stack = [];
function using(isAwait, value) {
if (value != null) {
if (Object(value) !== value) {
throw new TypeError(
"using declarations can only be used with objects, functions, null, or undefined.",
);
}
// core-js-pure uses Symbol.for for polyfilling well-known symbols
if (isAwait) {
var dispose =
value[Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")];
}
if (dispose == null) {
dispose = value[Symbol.dispose || Symbol.for("Symbol.dispose")];
}
if (typeof dispose !== "function") {
throw new TypeError(`Property [Symbol.dispose] is not a function.`);
}
stack.push({ v: value, d: dispose, a: isAwait });
} else if (isAwait) {
// provide the nullish `value` as `d` for minification gain
stack.push({ d: value, a: isAwait });
}
return value;
}
return {
// error
e: empty,
// using
u: using.bind(null, false),
// await using
a: using.bind(null, true),
// dispose
d: function () {
var error = this.e;
function next() {
// eslint-disable-next-line @typescript-eslint/no-use-before-define
while ((resource = stack.pop())) {
try {
var resource,
disposalResult = resource.d && resource.d.call(resource.v);
if (resource.a) {
return Promise.resolve(disposalResult).then(next, err);
}
} catch (e) {
return err(e);
}
}
if (error !== empty) throw error;
}
function err(e) {
error = error !== empty ? new _disposeSuppressedError(error, e) : e;
return next();
}
return next();
},
};
} | willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_wrap_async_generator.js | JavaScript | function _wrap_async_generator(fn) {
return function() {
return new _async_generator(fn.apply(this, arguments));
};
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_wrap_native_super.js | JavaScript | function _wrap_native_super(Class) {
var _cache = typeof Map === "function" ? new Map() : undefined;
_wrap_native_super = function wrapNativeSuper(Class) {
if (Class === null || !_is_native_function(Class)) return Class;
if (typeof Class !== "function") {
throw new TypeError("Super expression must either be null or a function");
}
if (typeof _cache !== "undefined") {
if (_cache.has(Class)) return _cache.get(Class);
_cache.set(Class, Wrapper);
}
function Wrapper() {
return _construct(Class, arguments, _get_prototype_of(this).constructor);
}
Wrapper.prototype = Object.create(Class.prototype, {
constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true }
});
return _set_prototype_of(Wrapper, Class);
};
return _wrap_native_super(Class);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/_write_only_error.js | JavaScript | function _write_only_error(name) {
throw new TypeError("\"" + name + "\" is write-only");
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/helpers/mod.rs | Rust | use std::{cell::RefCell, mem::replace};
use once_cell::sync::Lazy;
use rustc_hash::FxHashMap;
use swc_atoms::Atom;
use swc_common::{FileName, FilePathMapping, Mark, SourceMap, SyntaxContext, DUMMY_SP};
use swc_ecma_ast::*;
use swc_ecma_utils::{prepend_stmts, quote_ident, DropSpan, ExprFactory};
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
#[macro_export]
macro_rules! enable_helper {
($i:ident) => {{
$crate::helpers::HELPERS.with(|helpers| {
helpers.$i();
helpers.mark()
})
}};
}
fn parse(code: &str) -> Vec<Stmt> {
let cm = SourceMap::new(FilePathMapping::empty());
let fm = cm.new_source_file(
FileName::Custom(stringify!($name).into()).into(),
code.into(),
);
swc_ecma_parser::parse_file_as_script(
&fm,
Default::default(),
Default::default(),
None,
&mut Vec::new(),
)
.map(|mut script| {
script.body.visit_mut_with(&mut DropSpan);
script.body
})
.map_err(|e| {
unreachable!("Error occurred while parsing error: {:?}", e);
})
.unwrap()
}
macro_rules! add_to {
($buf:expr, $name:ident, $b:expr, $mark:expr) => {{
static STMTS: Lazy<Vec<Stmt>> = Lazy::new(|| {
let code = include_str!(concat!("./_", stringify!($name), ".js"));
parse(&code)
});
let enable = $b;
if enable {
$buf.extend(STMTS.iter().cloned().map(|mut stmt| {
stmt.visit_mut_with(&mut Marker {
base: SyntaxContext::empty().apply_mark($mark),
decls: Default::default(),
decl_ctxt: SyntaxContext::empty().apply_mark(Mark::new()),
});
stmt
}))
}
}};
}
macro_rules! add_import_to {
($buf:expr, $name:ident, $b:expr, $mark:expr) => {{
let enable = $b;
if enable {
let ctxt = SyntaxContext::empty().apply_mark($mark);
let s = ImportSpecifier::Named(ImportNamedSpecifier {
span: DUMMY_SP,
local: Ident::new(concat!("_", stringify!($name)).into(), DUMMY_SP, ctxt),
imported: Some(quote_ident!("_").into()),
is_type_only: false,
});
let src: Str = concat!("@swc/helpers/_/_", stringify!($name)).into();
$buf.push(ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {
span: DUMMY_SP,
specifiers: vec![s],
src: Box::new(src),
with: Default::default(),
type_only: Default::default(),
phase: Default::default(),
})))
}
}};
}
better_scoped_tls::scoped_tls!(
/// This variable is used to manage helper scripts like `_inherits` from babel.
///
/// The instance contains flags where each flag denotes if a helper script should be injected.
pub static HELPERS: Helpers
);
/// Tracks used helper methods. (e.g. __extends)
#[derive(Debug, Default)]
pub struct Helpers {
external: bool,
mark: HelperMark,
inner: RefCell<Inner>,
}
#[derive(Debug, Clone, Copy)]
pub struct HelperData {
external: bool,
mark: HelperMark,
inner: Inner,
}
impl Helpers {
pub fn new(external: bool) -> Self {
Helpers {
external,
mark: Default::default(),
inner: Default::default(),
}
}
pub const fn mark(&self) -> Mark {
self.mark.0
}
pub const fn external(&self) -> bool {
self.external
}
pub fn data(&self) -> HelperData {
HelperData {
inner: *self.inner.borrow(),
external: self.external,
mark: self.mark,
}
}
pub fn from_data(data: HelperData) -> Self {
Helpers {
external: data.external,
mark: data.mark,
inner: RefCell::new(data.inner),
}
}
}
#[derive(Debug, Clone, Copy)]
struct HelperMark(Mark);
impl Default for HelperMark {
fn default() -> Self {
HelperMark(Mark::new())
}
}
macro_rules! define_helpers {
(
Helpers {
$( $name:ident : ( $( $dep:ident ),* ), )*
}
) => {
#[derive(Debug,Default, Clone, Copy)]
struct Inner {
$( $name: bool, )*
}
impl Helpers {
$(
pub fn $name(&self) {
self.inner.borrow_mut().$name = true;
if !self.external {
$(
self.$dep();
)*
}
}
)*
}
impl Helpers {
pub fn extend_from(&self, other: &Self) {
let other = other.inner.borrow();
let mut me = self.inner.borrow_mut();
$(
if other.$name {
me.$name = true;
}
)*
}
}
impl InjectHelpers {
fn is_helper_used(&self) -> bool{
HELPERS.with(|helpers|{
let inner = helpers.inner.borrow();
false $(
|| inner.$name
)*
})
}
fn build_helpers(&self) -> Vec<Stmt> {
let mut buf = Vec::new();
HELPERS.with(|helpers|{
debug_assert!(!helpers.external);
let inner = helpers.inner.borrow();
$(
add_to!(buf, $name, inner.$name, helpers.mark.0);
)*
});
buf
}
fn build_imports(&self) -> Vec<ModuleItem> {
let mut buf = Vec::new();
HELPERS.with(|helpers|{
let inner = helpers.inner.borrow();
debug_assert!(helpers.external);
$(
add_import_to!(buf, $name, inner.$name, helpers.mark.0);
)*
});
buf
}
fn build_requires(&self) -> Vec<Stmt>{
let mut buf = Vec::new();
HELPERS.with(|helpers|{
debug_assert!(helpers.external);
let inner = helpers.inner.borrow();
$(
let enable = inner.$name;
if enable {
buf.push(self.build_reqire(stringify!($name), helpers.mark.0))
}
// add_require_to!(buf, $name, helpers.inner.$name, helpers.mark.0, self.global_mark);
)*
});
buf
}
}
};
}
define_helpers!(Helpers {
apply_decorated_descriptor: (),
array_like_to_array: (),
array_with_holes: (),
array_without_holes: (array_like_to_array),
assert_this_initialized: (),
async_generator: (await_value),
async_generator_delegate: (),
async_iterator: (),
async_to_generator: (),
await_async_generator: (await_value),
await_value: (),
call_super: (
get_prototype_of,
is_native_reflect_construct,
possible_constructor_return
),
check_private_redeclaration: (),
class_apply_descriptor_destructure: (),
class_apply_descriptor_get: (),
class_apply_descriptor_set: (),
class_apply_descriptor_update: (),
class_call_check: (),
class_check_private_static_field_descriptor: (),
class_extract_field_descriptor: (),
class_name_tdz_error: (),
class_private_field_get: (class_extract_field_descriptor, class_apply_descriptor_get),
class_private_field_init: (check_private_redeclaration),
class_private_field_loose_base: (),
class_private_field_loose_key: (),
class_private_field_set: (class_extract_field_descriptor, class_apply_descriptor_set),
class_private_field_update: (
class_extract_field_descriptor,
class_apply_descriptor_update
),
class_private_method_get: (),
class_private_method_init: (check_private_redeclaration),
class_private_method_set: (),
class_static_private_field_spec_get: (
class_check_private_static_access,
class_check_private_static_field_descriptor,
class_apply_descriptor_get
),
class_static_private_field_spec_set: (
class_check_private_static_access,
class_check_private_static_field_descriptor,
class_apply_descriptor_set
),
class_static_private_field_update: (
class_check_private_static_access,
class_check_private_static_field_descriptor,
class_apply_descriptor_update
),
construct: (is_native_reflect_construct, set_prototype_of),
create_class: (),
decorate: (to_array, to_property_key),
defaults: (),
define_enumerable_properties: (),
define_property: (),
export_star: (),
extends: (),
get: (super_prop_base),
get_prototype_of: (),
inherits: (set_prototype_of),
inherits_loose: (),
initializer_define_property: (),
initializer_warning_helper: (),
instanceof: (),
interop_require_default: (),
interop_require_wildcard: (),
is_native_function: (),
iterable_to_array: (),
iterable_to_array_limit: (),
iterable_to_array_limit_loose: (),
jsx: (),
new_arrow_check: (),
non_iterable_rest: (),
non_iterable_spread: (),
object_destructuring_empty: (),
object_spread: (define_property),
object_spread_props: (),
object_without_properties: (object_without_properties_loose),
object_without_properties_loose: (),
possible_constructor_return: (type_of, assert_this_initialized),
read_only_error: (),
set: (super_prop_base, define_property),
set_prototype_of: (),
skip_first_generator_next: (),
sliced_to_array: (
array_with_holes,
iterable_to_array_limit,
unsupported_iterable_to_array,
non_iterable_rest
),
sliced_to_array_loose: (
array_with_holes,
iterable_to_array_limit_loose,
unsupported_iterable_to_array,
non_iterable_rest
),
super_prop_base: (get_prototype_of),
tagged_template_literal: (),
tagged_template_literal_loose: (),
// temporal_ref: (temporal_undefined),
// temporal_undefined: (),
throw: (),
to_array: (
array_with_holes,
iterable_to_array,
unsupported_iterable_to_array,
non_iterable_rest
),
to_consumable_array: (
array_without_holes,
iterable_to_array,
unsupported_iterable_to_array,
non_iterable_spread
),
to_primitive: (type_of),
to_property_key: (type_of, to_primitive),
update: (get, set),
type_of: (),
unsupported_iterable_to_array: (array_like_to_array),
wrap_async_generator: (async_generator),
wrap_native_super: (
construct,
get_prototype_of,
set_prototype_of,
is_native_function
),
write_only_error: (),
class_private_field_destructure: (
class_extract_field_descriptor,
class_apply_descriptor_destructure
),
class_static_private_field_destructure: (
class_check_private_static_access,
class_extract_field_descriptor,
class_apply_descriptor_destructure
),
class_static_private_method_get: (class_check_private_static_access),
class_check_private_static_access: (),
is_native_reflect_construct: (),
create_super: (
get_prototype_of,
is_native_reflect_construct,
possible_constructor_return
),
create_for_of_iterator_helper_loose: (unsupported_iterable_to_array),
ts_decorate: (),
ts_generator: (),
ts_metadata: (),
ts_param: (),
ts_values: (),
ts_add_disposable_resource: (),
ts_dispose_resources: (),
apply_decs_2203_r: (),
identity: (),
dispose: (),
using: (),
using_ctx: (),
});
pub fn inject_helpers(global_mark: Mark) -> impl Pass + VisitMut {
visit_mut_pass(InjectHelpers {
global_mark,
helper_ctxt: None,
})
}
struct InjectHelpers {
global_mark: Mark,
helper_ctxt: Option<SyntaxContext>,
}
impl InjectHelpers {
fn make_helpers_for_module(&mut self) -> Vec<ModuleItem> {
let (helper_mark, external) = HELPERS.with(|helper| (helper.mark(), helper.external()));
if external {
if self.is_helper_used() {
self.helper_ctxt = Some(SyntaxContext::empty().apply_mark(helper_mark));
self.build_imports()
} else {
Vec::new()
}
} else {
self.build_helpers()
.into_iter()
.map(ModuleItem::Stmt)
.collect()
}
}
fn make_helpers_for_script(&mut self) -> Vec<Stmt> {
let (helper_mark, external) = HELPERS.with(|helper| (helper.mark(), helper.external()));
if external {
if self.is_helper_used() {
self.helper_ctxt = Some(SyntaxContext::empty().apply_mark(helper_mark));
self.build_requires()
} else {
Default::default()
}
} else {
self.build_helpers()
}
}
fn build_reqire(&self, name: &str, mark: Mark) -> Stmt {
let c = CallExpr {
span: DUMMY_SP,
callee: Expr::from(Ident {
span: DUMMY_SP,
ctxt: SyntaxContext::empty().apply_mark(self.global_mark),
sym: "require".into(),
..Default::default()
})
.as_callee(),
args: vec![Str {
span: DUMMY_SP,
value: format!("@swc/helpers/_/_{}", name).into(),
raw: None,
}
.as_arg()],
..Default::default()
};
let ctxt = SyntaxContext::empty().apply_mark(mark);
VarDecl {
kind: VarDeclKind::Var,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: Pat::Ident(Ident::new(format!("_{}", name).into(), DUMMY_SP, ctxt).into()),
init: Some(c.into()),
definite: false,
}],
..Default::default()
}
.into()
}
fn map_helper_ref_ident(&mut self, ref_ident: &Ident) -> Option<Expr> {
self.helper_ctxt
.filter(|ctxt| ctxt == &ref_ident.ctxt)
.map(|_| {
let ident = ref_ident.clone().without_loc();
MemberExpr {
span: ref_ident.span,
obj: Box::new(ident.into()),
prop: MemberProp::Ident("_".into()),
}
.into()
})
}
}
impl VisitMut for InjectHelpers {
noop_visit_mut_type!();
fn visit_mut_module(&mut self, module: &mut Module) {
let helpers = self.make_helpers_for_module();
prepend_stmts(&mut module.body, helpers.into_iter());
}
fn visit_mut_script(&mut self, script: &mut Script) {
let helpers = self.make_helpers_for_script();
let helpers_is_empty = helpers.is_empty();
prepend_stmts(&mut script.body, helpers.into_iter());
if !helpers_is_empty {
script.visit_mut_children_with(self);
}
}
fn visit_mut_expr(&mut self, n: &mut Expr) {
match n {
Expr::Ident(ref_ident) => {
if let Some(expr) = self.map_helper_ref_ident(ref_ident) {
*n = expr;
}
}
_ => n.visit_mut_children_with(self),
};
}
}
struct Marker {
base: SyntaxContext,
decls: FxHashMap<Atom, SyntaxContext>,
decl_ctxt: SyntaxContext,
}
impl VisitMut for Marker {
noop_visit_mut_type!();
fn visit_mut_fn_decl(&mut self, n: &mut FnDecl) {
let old_decl_ctxt = replace(
&mut self.decl_ctxt,
SyntaxContext::empty().apply_mark(Mark::new()),
);
let old_decls = self.decls.clone();
n.visit_mut_children_with(self);
self.decls = old_decls;
self.decl_ctxt = old_decl_ctxt;
}
fn visit_mut_fn_expr(&mut self, n: &mut FnExpr) {
let old_decl_ctxt = replace(
&mut self.decl_ctxt,
SyntaxContext::empty().apply_mark(Mark::new()),
);
let old_decls = self.decls.clone();
n.visit_mut_children_with(self);
self.decls = old_decls;
self.decl_ctxt = old_decl_ctxt;
}
fn visit_mut_ident(&mut self, i: &mut Ident) {
i.ctxt = self.decls.get(&i.sym).copied().unwrap_or(self.base);
}
fn visit_mut_member_prop(&mut self, p: &mut MemberProp) {
if let MemberProp::Computed(p) = p {
p.visit_mut_with(self);
}
}
fn visit_mut_param(&mut self, n: &mut Param) {
if let Pat::Ident(i) = &n.pat {
self.decls.insert(i.sym.clone(), self.decl_ctxt);
}
n.visit_mut_children_with(self);
}
fn visit_mut_prop_name(&mut self, n: &mut PropName) {
if let PropName::Computed(e) = n {
e.visit_mut_with(self);
}
}
fn visit_mut_super_prop(&mut self, p: &mut SuperProp) {
if let SuperProp::Computed(p) = p {
p.visit_mut_with(self);
}
}
fn visit_mut_var_declarator(&mut self, v: &mut VarDeclarator) {
if let Pat::Ident(i) = &mut v.name {
if &*i.sym == "id" || &*i.sym == "resource" {
i.ctxt = self.base;
self.decls.insert(i.sym.clone(), self.base);
return;
}
if !(i.sym.starts_with("__") && i.sym.starts_with("_ts_")) {
self.decls.insert(i.sym.clone(), self.decl_ctxt);
}
}
v.visit_mut_children_with(self);
}
}
#[cfg(test)]
mod tests {
use testing::DebugUsingDisplay;
use super::*;
#[test]
fn external_helper() {
let input = "_throw()";
crate::tests::Tester::run(|tester| {
HELPERS.set(&Helpers::new(true), || {
let expected = tester.apply_transform(
DropSpan,
"output.js",
Default::default(),
"import { _ as _throw } from \"@swc/helpers/_/_throw\";
_throw();",
)?;
enable_helper!(throw);
eprintln!("----- Actual -----");
let tr = inject_helpers(Mark::new());
let actual = tester
.apply_transform(tr, "input.js", Default::default(), input)?
.apply(crate::hygiene::hygiene())
.apply(crate::fixer::fixer(None));
if actual == expected {
return Ok(());
}
let (actual_src, expected_src) = (tester.print(&actual), tester.print(&expected));
if actual_src == expected_src {
return Ok(());
}
println!(">>>>> Orig <<<<<\n{}", input);
println!(">>>>> Code <<<<<\n{}", actual_src);
assert_eq!(
DebugUsingDisplay(&actual_src),
DebugUsingDisplay(&expected_src)
);
Err(())
})
});
}
#[test]
fn use_strict_before_helper() {
crate::tests::test_transform(
Default::default(),
|_| {
enable_helper!(throw);
inject_helpers(Mark::new())
},
"'use strict'",
"'use strict'
function _throw(e) {
throw e;
}
",
false,
Default::default,
)
}
#[test]
fn name_conflict() {
crate::tests::test_transform(
Default::default(),
|_| {
enable_helper!(throw);
inject_helpers(Mark::new())
},
"let _throw = null",
"function _throw(e) {
throw e;
}
let _throw1 = null;
",
false,
Default::default,
)
}
#[test]
fn use_strict_abort() {
crate::tests::test_transform(
Default::default(),
|_| noop_pass(),
"'use strict'
let x = 4;",
"'use strict'
let x = 4;",
false,
Default::default,
);
}
#[test]
fn issue_8871() {
crate::tests::test_transform(
Default::default(),
|_| {
enable_helper!(using_ctx);
inject_helpers(Mark::new())
},
"let _throw = null",
r#"
function _using_ctx() {
var _disposeSuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed) {
var err = new Error();
err.name = "SuppressedError";
err.suppressed = suppressed;
err.error = error;
return err;
}, empty = {}, stack = [];
function using(isAwait, value) {
if (value != null) {
if (Object(value) !== value) {
throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
}
if (isAwait) {
var dispose = value[Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")];
}
if (dispose == null) {
dispose = value[Symbol.dispose || Symbol.for("Symbol.dispose")];
}
if (typeof dispose !== "function") {
throw new TypeError(`Property [Symbol.dispose] is not a function.`);
}
stack.push({
v: value,
d: dispose,
a: isAwait
});
} else if (isAwait) {
stack.push({
d: value,
a: isAwait
});
}
return value;
}
return {
e: empty,
u: using.bind(null, false),
a: using.bind(null, true),
d: function() {
var error = this.e;
function next() {
while(resource = stack.pop()){
try {
var resource, disposalResult = resource.d && resource.d.call(resource.v);
if (resource.a) {
return Promise.resolve(disposalResult).then(next, err);
}
} catch (e) {
return err(e);
}
}
if (error !== empty) throw error;
}
function err(e) {
error = error !== empty ? new _disposeSuppressedError(error, e) : e;
return next();
}
return next();
}
};
}
let _throw = null;
"#,
false,
Default::default,
)
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/hygiene/mod.rs | Rust | use rustc_hash::FxHashSet;
use swc_atoms::Atom;
use swc_common::Mark;
use swc_ecma_ast::*;
use swc_ecma_utils::stack_size::maybe_grow_default;
use swc_ecma_visit::{noop_visit_mut_type, visit_mut_pass, VisitMut, VisitMutWith};
pub use crate::rename::rename;
use crate::rename::{renamer, Renamer};
#[cfg(test)]
mod tests;
#[derive(Debug, Clone, Default)]
pub struct Config {
/// If true, the `hygiene` pass will preserve class names.
pub keep_class_names: bool,
/// The marks derived from this marks will treated as `specified by user`
/// and other marks will be treated as `generated by swc`.
pub top_level_mark: Mark,
/// Mangle even if vars are visible to `eval` or `with`.
pub ignore_eval: bool,
/// Used for preventing mangler from renaming variables to reserved names.
pub preserved_symbols: FxHashSet<Atom>,
}
/// See [hygiene_with_config] for doc. Creates a `hygiene` pass with default
/// value of [Config].
pub fn hygiene() -> impl Pass + VisitMut {
hygiene_with_config(Default::default())
}
/// The pass actually modifies the identifiers in the way that different
/// identifier (with respect to span hygiene) becomes different identifier.
/// (e.g. `a1` for `a#6`, `a2` for `a#23`)
///
/// # Implementation details
///
/// This document exists For curious people and potential contributors.
///
/// `hygiene` consists of three phases.
///
/// ## First phase
///
/// At first phase, we mark (using [swc_common::Mark]) nodes which can be
/// considered as a `scope`. e.g. [Function], [BlockStmt], [ArrowExpr]
///
/// ## Second phase
///
/// At second phase, we analyzes the file and determine identifiers to rename.
///
/// Note that we store scoping information for each node, using the fact that
/// [SyntaxContext] of all `scope` nodes are unique, thanks to the first phase.
///
///
/// ## Third phase
///
/// At third phase, we rename all identifiers in the queue.
pub fn hygiene_with_config(config: Config) -> impl 'static + Pass + VisitMut {
(
renamer(config, HygieneRenamer),
visit_mut_pass(HygieneRemover),
)
}
struct HygieneRenamer;
impl Renamer for HygieneRenamer {
const MANGLE: bool = false;
const RESET_N: bool = true;
fn new_name_for(&self, orig: &Id, n: &mut usize) -> swc_atoms::Atom {
let res = if *n == 0 {
orig.0.clone()
} else {
format!("{}{}", orig.0, n).into()
};
*n += 1;
res
}
}
struct HygieneRemover;
impl VisitMut for HygieneRemover {
noop_visit_mut_type!();
fn visit_mut_expr(&mut self, n: &mut Expr) {
maybe_grow_default(|| n.visit_mut_children_with(self));
}
fn visit_mut_ident(&mut self, i: &mut Ident) {
i.ctxt = Default::default();
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/hygiene/tests.rs | Rust | use rustc_hash::FxHashMap;
use swc_atoms::Atom;
use swc_common::{hygiene::*, DUMMY_SP};
use swc_ecma_parser::Syntax;
use swc_ecma_utils::quote_ident;
use swc_ecma_visit::{Fold, FoldWith};
use testing::{assert_eq, DebugUsingDisplay};
use super::*;
use crate::tests::{HygieneVisualizer, Tester};
struct Marker {
map: FxHashMap<Atom, Mark>,
}
fn marker(markers: &[(&str, Mark)]) -> Marker {
Marker {
map: markers.iter().map(|(k, v)| ((*k).into(), *v)).collect(),
}
}
impl Fold for Marker {
fn fold_ident(&mut self, mut ident: Ident) -> Ident {
if let Some(mark) = self.map.get(&ident.sym) {
ident.ctxt = ident.ctxt.apply_mark(*mark);
}
ident
}
}
struct OnceMarker {
map: FxHashMap<Atom, Vec<Mark>>,
}
impl OnceMarker {
fn new(markers: &[(&str, &[Mark])]) -> OnceMarker {
OnceMarker {
map: markers
.iter()
.map(|(k, v)| ((*k).into(), (*v).into()))
.collect(),
}
}
}
impl Fold for OnceMarker {
fn fold_ident(&mut self, mut ident: Ident) -> Ident {
if let Some(marks) = self.map.get_mut(&ident.sym) {
ident.ctxt = ident.ctxt.apply_mark(marks.remove(0));
}
ident
}
fn fold_prop_name(&mut self, prop: PropName) -> PropName {
match prop {
PropName::Computed(_) => prop.fold_children_with(self),
_ => prop,
}
}
}
fn test<F>(op: F, expected: &str)
where
F: FnOnce(&mut Tester<'_>) -> Result<Vec<Stmt>, ()>,
{
test_module(
|tester| {
Ok(Module {
span: DUMMY_SP,
body: op(tester)?.into_iter().map(ModuleItem::Stmt).collect(),
shebang: None,
})
},
expected,
Default::default,
)
}
fn test_module<F>(op: F, expected: &str, config: impl FnOnce() -> Config)
where
F: FnOnce(&mut crate::tests::Tester<'_>) -> Result<Module, ()>,
{
crate::tests::Tester::run(|tester| {
let mut module = Program::Module(op(tester)?);
let hygiene_src = tester.print(&module.clone().fold_with(&mut HygieneVisualizer));
println!("----- Hygiene -----\n{}", hygiene_src);
hygiene_with_config(config()).process(&mut module);
let actual = tester.print(&module);
let expected = {
let expected = tester
.with_parser("expected.js", Syntax::default(), expected, |p| {
p.parse_module()
})
.map(Program::Module)?;
tester.print(&expected)
};
if actual != expected {
println!("----- Actual -----\n{}", actual);
println!("----- Diff -----");
assert_eq!(DebugUsingDisplay(&actual), DebugUsingDisplay(&expected));
}
Ok(())
})
}
#[test]
fn simple() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(vec![
tester
.parse_stmt("actual1.js", "var foo = 1;")?
.fold_with(&mut marker(&[("foo", mark1)])),
tester
.parse_stmt("actual2.js", "var foo = 2;")?
.fold_with(&mut marker(&[("foo", mark2)])),
tester
.parse_stmt("actual3.js", "use(foo)")?
.fold_with(&mut marker(&[("foo", mark1)])),
])
},
"
var foo = 1;
var foo1 = 2;
use(foo);
",
);
}
#[test]
fn block_scoping_with_usage() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let stmts = vec![
tester
.parse_stmt("actual1.js", "var foo = 1;")?
.fold_with(&mut marker(&[("foo", mark1)])),
tester
.parse_stmt("actual2.js", "{ let foo = 2; use(foo); }")?
.fold_with(&mut marker(&[("foo", mark2)])),
tester
.parse_stmt("actual3.js", "use(foo)")?
.fold_with(&mut marker(&[("foo", mark1)])),
];
Ok(stmts)
},
"
var foo = 1;
{
let foo = 2;
use(foo);
}
use(foo);",
);
}
#[test]
fn block_scoping_no_usage() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(mark1);
let stmts = vec![
tester
.parse_stmt("actual1.js", "let foo;")?
.fold_with(&mut marker(&[("foo", mark1)])),
tester
.parse_stmt("actual2.js", "{ let foo }")?
.fold_with(&mut marker(&[("foo", mark2)])),
];
Ok(stmts)
},
"
let foo;
{
let foo;
}
",
);
}
#[test]
fn fn_binding_ident() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(vec![
tester
.parse_stmt("actual1.js", "var foo = function baz(){}")?
.fold_with(&mut marker(&[("baz", mark1)])),
tester
.parse_stmt("actual2.js", "var bar = function baz(){};")?
.fold_with(&mut marker(&[("baz", mark2)])),
tester
.parse_stmt("actual3.js", "use(baz)")?
.fold_with(&mut marker(&[("baz", mark1)])),
])
},
"var foo = function baz(){};
var bar = function baz(){};
use(baz);",
);
}
#[test]
fn fn_binding_ident_in_call() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(mark1);
let mark3 = Mark::fresh(mark1);
Ok(vec![
tester
.parse_stmt("actual1.js", "var foo = use(function baz(){})")?
.fold_with(&mut marker(&[("baz", mark1)])),
tester
.parse_stmt("actual2.js", "var bar1 = use(function baz(){})")?
.fold_with(&mut marker(&[("baz", mark2)])),
tester
.parse_stmt("actual3.js", "var bar2 = use(function baz(){})")?
.fold_with(&mut marker(&[("baz", mark3)])),
tester
.parse_stmt("actual4.js", "use(baz)")?
.fold_with(&mut marker(&[("baz", mark1)])),
])
},
"var foo = use(function baz(){});
var bar1 = use(function baz(){});
var bar2 = use(function baz(){});
use(baz);",
);
}
#[test]
fn member_expr() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(mark1);
Ok(vec![
tester
.parse_stmt("actual1.js", "let a;")?
.fold_with(&mut marker(&[("a", mark1)])),
tester
.parse_stmt("actual2.js", "foo.a = init")?
.fold_with(&mut marker(&[("a", mark2)])),
])
},
"let a;
foo.a = init",
);
}
#[test]
fn const_then_fn_param() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(mark1);
Ok(vec![
tester
.parse_stmt("actual1.js", "const a = 1;")?
.fold_with(&mut marker(&[("a", mark1)])),
tester
.parse_stmt("actual2.js", "function foo(a) {use(a);}")?
.fold_with(&mut marker(&[("a", mark2)])),
])
},
"const a = 1;
function foo(a) {
use(a);
}",
);
}
#[test]
fn for_loop() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(mark1);
let mark3 = Mark::fresh(mark1);
Ok(vec![
tester
.parse_stmt("actual1.js", "for(var a=1;;) {}")?
.fold_with(&mut marker(&[("a", mark1)])),
tester
.parse_stmt("actual2.js", "for(var a of foo) {}")?
.fold_with(&mut marker(&[("a", mark2)])),
tester
.parse_stmt("actual3.js", "for(var a=3;;) {}")?
.fold_with(&mut marker(&[("a", mark3)])),
])
},
"
for(var a=1;;) {}
for(var a1 of foo) {}
for(var a2 = 3;;) {}
",
);
}
#[test]
fn try_for_loop() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(mark1);
let mark3 = Mark::fresh(mark1);
Ok(vec![
tester
.parse_stmt("actual1.js", "try { for(var a=1;;) {} } finally {}")?
.fold_with(&mut marker(&[("a", mark1)])),
tester
.parse_stmt("actual2.js", "for(var a of foo) {}")?
.fold_with(&mut marker(&[("a", mark2)])),
tester
.parse_stmt("actual3.js", "for(var a=3;;) {}")?
.fold_with(&mut marker(&[("a", mark3)])),
])
},
"
try {
for(var a=1;;) {}
} finally {
}
for(var a1 of foo) {}
for(var a2 = 3;;) {}
",
);
}
#[test]
fn shorthand() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(mark1);
Ok(vec![
tester
.parse_stmt("actual1.js", "let a = 1;")?
.fold_with(&mut marker(&[("a", mark1)])),
tester
.parse_stmt(
"actual2.js",
"function foo() {
let a = 2;
use({ a })
}",
)?
.fold_with(&mut marker(&[("a", mark2)])),
])
},
"
let a = 1;
function foo() {
let a = 2;
use({ a })
}
",
);
}
#[test]
fn same_mark() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
Ok(vec![
tester
.parse_stmt("actual1.js", "var a = 1;")?
.fold_with(&mut marker(&[("a", mark1)])),
tester
.parse_stmt("actual2.js", "var a = 1;")?
.fold_with(&mut marker(&[("a", mark1)])),
])
},
"
var a = 1;
var a = 1;
",
);
}
#[test]
fn mark_root() {
test(
|tester| {
let mark2 = Mark::fresh(Mark::root());
Ok(vec![
tester.parse_stmt("actual1.js", "var foo = 'bar';")?,
Stmt::Decl(Decl::Fn(FnDecl {
ident: quote_ident!("Foo").into(),
function: Box::new(Function {
span: DUMMY_SP,
is_async: false,
is_generator: false,
decorators: Vec::new(),
body: Some(BlockStmt {
stmts: vec![
tester
.parse_stmt("actual2.js", "var foo = 'foo';")?
.fold_with(&mut marker(&[("foo", mark2)])),
tester.parse_stmt(
"actual3.js",
"_define_property(this, 'bar', foo);",
)?,
],
..Default::default()
}),
params: Vec::new(),
..Default::default()
}),
declare: false,
})),
])
},
"
var foo = 'bar';
function Foo() {
var foo1 = 'foo';
_define_property(this, 'bar', foo);
}
",
);
}
#[test]
fn var_class_decl() {
test(
|tester| {
Ok(vec![
tester.parse_stmt("actual1.js", "var Foo = function Foo(){}")?
])
},
"var Foo = function Foo(){}",
);
}
#[test]
fn var_class_decl_2() {
test(
|tester| {
Ok(vec![tester
.parse_stmt(
"actual1.js",
"
var Foo = (function() {
function Foo() {}
return Foo;
}())
",
)?
.fold_with(&mut marker(&[(
"Foo",
Mark::fresh(Mark::root()),
)]))])
},
"
var Foo = (function(){
function Foo(){
}
return Foo;
}())
",
);
}
#[test]
fn fn_args() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(vec![Stmt::Decl(Decl::Fn(FnDecl {
ident: quote_ident!("Foo").into(),
function: Box::new(Function {
span: DUMMY_SP,
is_async: false,
is_generator: false,
decorators: Vec::new(),
body: Some(BlockStmt {
stmts: vec![tester
.parse_stmt("actual1.js", "_define_property(this, 'force', force);")?
.fold_with(&mut marker(&[("force", mark2)]))],
..Default::default()
}),
params: vec![Param {
span: DUMMY_SP,
decorators: Vec::new(),
pat: quote_ident!("force").into(),
}
.fold_with(&mut marker(&[("force", mark1)]))],
..Default::default()
}),
declare: false,
}))])
},
"
function Foo(force1) {
_define_property(this, 'force', force);
}
",
);
}
#[test]
fn block_in_fn() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(mark1);
Ok(vec![Stmt::Decl(Decl::Fn(FnDecl {
ident: quote_ident!("Foo").into(),
function: Box::new(Function {
span: DUMMY_SP,
is_async: false,
is_generator: false,
decorators: Vec::new(),
body: Some(BlockStmt {
stmts: vec![
tester
.parse_stmt("actual1.js", "var bar;")?
.fold_with(&mut marker(&[("bar", mark1)])),
tester
.parse_stmt("actual2.js", "{ var bar; }")?
.fold_with(&mut marker(&[("bar", mark2)])),
],
..Default::default()
}),
params: Vec::new(),
..Default::default()
}),
declare: false,
}))])
},
"
// Ideal:
//
// function Foo() {
// var bar;
// {
// var bar;
// }
// }
function Foo() {
var bar;
{
var bar1;
}
}
",
);
}
#[test]
fn flat_in_fn() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(mark1);
Ok(vec![Stmt::Decl(Decl::Fn(FnDecl {
ident: quote_ident!("Foo").into(),
function: Box::new(Function {
span: DUMMY_SP,
is_async: false,
is_generator: false,
decorators: Vec::new(),
body: Some(BlockStmt {
stmts: vec![
tester
.parse_stmt("actual1.js", "var bar;")?
.fold_with(&mut marker(&[("bar", mark1)])),
tester
.parse_stmt("actual2.js", "var bar;")?
.fold_with(&mut marker(&[("bar", mark2)])),
],
..Default::default()
}),
params: Vec::new(),
..Default::default()
}),
declare: false,
}))])
},
"
function Foo() {
var bar;
var bar1;
}
",
);
}
#[test]
fn params_in_fn() {
test(
|_tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(vec![Stmt::Decl(Decl::Fn(FnDecl {
ident: quote_ident!("Foo").into(),
function: Box::new(Function {
span: DUMMY_SP,
is_async: false,
is_generator: false,
decorators: Vec::new(),
body: Some(BlockStmt {
..Default::default()
}),
params: vec![
Param {
span: DUMMY_SP,
decorators: Default::default(),
pat: Ident::new(
"param".into(),
DUMMY_SP,
SyntaxContext::empty().apply_mark(mark1),
)
.into(),
},
Param {
span: DUMMY_SP,
decorators: Default::default(),
pat: Ident::new(
"param".into(),
DUMMY_SP,
SyntaxContext::empty().apply_mark(mark2),
)
.into(),
},
],
..Default::default()
}),
declare: false,
}))])
},
"function Foo(param, param1) {}",
);
}
#[test]
fn next_fn() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(vec![
tester
.parse_stmt("actual1.js", "function foo(param){}")?
.fold_with(&mut marker(&[("param", mark1)])),
tester
.parse_stmt("actual2.js", "function bar(param){}")?
.fold_with(&mut marker(&[("param", mark2)])),
])
},
"
function foo(param) {}
function bar(param) {}
",
);
}
#[test]
fn for_x() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(mark1);
let mark3 = Mark::fresh(mark1);
let mark4 = Mark::fresh(mark3);
Ok(vec![
tester
.parse_stmt(
"actual1.js",
"for (var _ref of []){
var { a } = _ref, b = _object_without_properties(_ref, ['a']);
}",
)?
.fold_with(&mut marker(&[("_ref", mark1)])),
tester
.parse_stmt(
"actual2.js",
"for (var _ref of []){
var { a } = _ref, b = _object_without_properties(_ref, ['a']);
}",
)?
.fold_with(&mut marker(&[("_ref", mark2)])),
tester
.parse_stmt(
"actual3.js",
"async function a() {
for await (var _ref of []){
var { a } = _ref, b = _object_without_properties(_ref, ['a']);
}
}",
)?
.fold_with(&mut marker(&[("_ref", mark4)])),
])
},
"
for (var _ref of []){
var { a } = _ref, b = _object_without_properties(_ref, ['a']);
}
for (var _ref1 of []){
var { a } = _ref1, b = _object_without_properties(_ref1, ['a']);
}
async function a() {
for await (var _ref of []){
var { a } = _ref, b = _object_without_properties(_ref, ['a']);
}
}
",
);
}
#[test]
fn fn_param_same_name() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(vec![tester
.parse_stmt("actual1.js", "function foo(param, param){}")?
.fold_with(&mut OnceMarker::new(&[(
"param",
&[mark1, mark2],
)]))])
},
"function foo(param, param1){}",
);
}
#[test]
fn fn_param_same_name_in_arg() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(vec![tester
.parse_stmt("actual1.js", "use(function (param, param){})")?
.fold_with(&mut OnceMarker::new(&[(
"param",
&[mark1, mark2],
)]))])
},
"use(function (param, param1){})",
);
}
#[test]
fn nested_fn_param_with_same_name() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(vec![tester
.parse_stmt(
"actual1.js",
"
function _three() {
_three = _async_to_generator(function*(a, param, c, param) {
});
return _three.apply(this, arguments);
}
",
)?
.fold_with(&mut OnceMarker::new(&[(
"param",
&[mark1, mark2],
)]))])
},
"
function _three() {
_three = _async_to_generator(function*(a, param, c, param1) {
});
return _three.apply(this, arguments);
}
",
);
}
#[test]
fn regression_001() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let mark3 = Mark::fresh(Mark::root());
let mark4 = Mark::fresh(Mark::root());
Ok(vec![tester
.parse_stmt(
"actual1.js",
"var Foo = function() {
function Foo() {
_class_call_check(this, Foo);
foo.set(this, {
writable: true, value: 0
});
}
_create_class(Foo, [{
key: 'test', value: function test(other) {
var old, _obj, old, _obj;
_class_private_field_set(this, foo, (old = +_class_private_field_get(this, \
foo)) + 1), old;
_class_private_field_set(_obj = other.obj, foo, (old = \
+_class_private_field_get(_obj, foo)) + 1), old;
}
}]);
return Foo;
}();
",
)?
.fold_with(&mut OnceMarker::new(&[
("old", &[mark1, mark2, mark1, mark1, mark2, mark2]),
("_obj", &[mark3, mark4, mark3, mark4]),
]))])
},
"var Foo = function() {
function Foo() {
_class_call_check(this, Foo);
foo.set(this, {
writable: true, value: 0
});
}
_create_class(Foo, [{
key: 'test', value: function test(other) {
var old, _obj, old1, _obj1;
_class_private_field_set(this, foo, (old = +_class_private_field_get(this, foo)) + \
1), old;
_class_private_field_set(_obj = other.obj, foo, (old1 = \
+_class_private_field_get(_obj1, foo)) + 1), old1;
}
}]);
return Foo;
}();
",
);
}
#[test]
fn regression_002() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(vec![tester
.parse_stmt(
"actual1.js",
"_create_class(Foo, [{
key: 'test', value: function test(other) {
var old, _obj, old, _obj;
_class_private_field_set(this, foo, (old = +_class_private_field_get(this, \
foo)) + 1), old;
_class_private_field_set(_obj = other.obj, foo, (old = \
+_class_private_field_get(_obj, foo)) + 1), old;
}
}])",
)?
.fold_with(&mut OnceMarker::new(&[(
"old",
&[mark1, mark2, mark1, mark1, mark2, mark2],
)]))])
},
"_create_class(Foo, [{
key: 'test', value: function test(other) {
var old, _obj, old1, _obj;
_class_private_field_set(this, foo, (old = +_class_private_field_get(this, \
foo)) + 1), old;
_class_private_field_set(_obj = other.obj, foo, (old1 = \
+_class_private_field_get(_obj, foo)) + 1), old1;
}
}]);",
);
}
#[test]
fn regression_003() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(tester
.parse_stmts(
"actual1.js",
"var old, _obj, old, _obj;
_class_private_field_set(this, foo, (old = +_class_private_field_get(this, \
foo)) + 1), old;
_class_private_field_set(_obj = other.obj, foo, (old = \
+_class_private_field_get(_obj, foo)) + 1), old;",
)?
.fold_with(&mut OnceMarker::new(&[(
"old",
&[mark1, mark2, mark1, mark1, mark2, mark2],
)])))
},
"var old, _obj, old1, _obj;
_class_private_field_set(this, foo, (old = +_class_private_field_get(this, \
foo)) + 1), old;
_class_private_field_set(_obj = other.obj, foo, (old1 = \
+_class_private_field_get(_obj, foo)) + 1), old1;",
);
}
#[test]
fn regression_004() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(tester
.parse_stmts(
"actual1.js",
"function foo(...args){}
function bar(...args){}",
)?
.fold_with(&mut OnceMarker::new(&[("args", &[mark1, mark2])])))
},
"function foo(...args){}
function bar(...args){}",
);
}
#[test]
fn regression_005() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(tester
.parse_stmts(
"actual1.js",
"var foo = (...args)=>{}
var bar = (...args)=>{}",
)?
.fold_with(&mut OnceMarker::new(&[("args", &[mark1, mark2])])))
},
"var foo = (...args)=>{}
var bar = (...args)=>{}",
);
}
#[test]
fn module_01() {
test_module(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(tester
.parse_module(
"actual1.js",
"import foo from 'src1';
import foo from 'src2';",
)?
.fold_with(&mut OnceMarker::new(&[("foo", &[mark1, mark2])])))
},
"import foo from 'src1';
import foo1 from 'src2';",
Default::default,
);
}
#[test]
fn module_02() {
test_module(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(tester
.parse_module(
"actual1.js",
"import {foo} from 'src1';
import {foo} from 'src2';",
)?
.fold_with(&mut OnceMarker::new(&[("foo", &[mark1, mark2])])))
},
"import {foo} from 'src1';
import {foo as foo1} from 'src2';",
Default::default,
);
}
#[test]
fn module_03() {
test_module(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(tester
.parse_module(
"actual1.js",
"var foo = 1;
var foo = 2;
export {foo}",
)?
.fold_with(&mut OnceMarker::new(&[("foo", &[mark1, mark2, mark2])])))
},
"var foo = 1;
var foo1 = 2;
export {foo1 as foo}",
Default::default,
);
}
#[test]
fn issue_281_01() {
test_module(
|tester| {
let mark1 = Mark::fresh(Mark::root());
Ok(tester
.parse_module(
"actual1.js",
"label: {
break label
}",
)?
.fold_with(&mut OnceMarker::new(&[("label", &[mark1, mark1])])))
},
"label: {
break label
}",
Default::default,
);
}
#[test]
fn issue_281_02() {
test_module(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let mark3 = Mark::fresh(Mark::root());
Ok(tester
.parse_module(
"actual1.js",
"function foo(e) {
e: {
try {
} catch (e) {
o = null;
break e
}
}
}",
)?
.fold_with(&mut OnceMarker::new(&[(
"e",
&[mark1, mark2, mark3, mark2],
)])))
},
"function foo(e1) {
e: {
try {
} catch (e1) {
o = null;
break e
}
}
}",
Default::default,
);
}
#[test]
fn issue_295_01() {
test_module(
|tester| {
let mark1 = Mark::fresh(Mark::root());
Ok(tester
.parse_module(
"actual1.js",
"export const bar = {};
class Foo {
constructor() {
bar;
}
}",
)?
.fold_with(&mut OnceMarker::new(&[("bar", &[mark1, mark1, mark1])])))
},
"
export const bar = {
};
class Foo {
constructor(){
bar;
}
}
",
Default::default,
);
}
#[test]
fn issue_295_02() {
test_module(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(tester
.parse_module(
"actual1.js",
"export const bar = {};
class Foo {
constructor() {
bar;
}
}",
)?
.fold_with(&mut OnceMarker::new(&[("bar", &[mark1, mark2])])))
},
"
const bar1 = {
};
export { bar1 as bar };
class Foo {
constructor(){
bar;
}
}
",
Default::default,
);
}
#[test]
fn exported_function() {
test_module(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(tester
.parse_module(
"actual1.js",
"const foo = {};
export function foo(){}",
)?
.fold_with(&mut OnceMarker::new(&[("foo", &[mark1, mark2])])))
},
"const foo = {};
function foo1(){}
export { foo1 as foo };",
Default::default,
);
}
#[test]
fn exported_class_1() {
test_module(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(tester
.parse_module(
"actual1.js",
"var Foo = {};
export class Foo {}",
)?
.fold_with(&mut OnceMarker::new(&[("Foo", &[mark1, mark2])])))
},
"var Foo = {};
class Foo1 {}
export { Foo1 as Foo };",
Default::default,
);
}
#[test]
fn issue_1279() {
test_module(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(tester
.parse_module(
"actual1.js",
"class Foo {
method() {
class Foo {}
new Foo();
}
}",
)?
.fold_with(&mut OnceMarker::new(&[("Foo", &[mark1, mark2, mark1])])))
},
"
let Foo = class Foo {
method() {
let Foo1 = class Foo {
};
new Foo();
}
};
",
|| Config {
keep_class_names: true,
..Default::default()
},
);
}
#[test]
#[ignore = "Postponed"]
fn issue_1507() {
test_module(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
Ok(tester
.parse_module(
"actual1.js",
"class Foo {
method() {
const cls = class Foo {
method() {
new Foo();
}
}
}
}",
)?
.fold_with(&mut OnceMarker::new(&[("Foo", &[mark1, mark2, mark1])])))
},
"
let Foo1 = class Foo {
method() {
const cls = class Foo {
method() {
new Foo1();
}
};
}
};
",
|| Config {
keep_class_names: true,
..Default::default()
},
);
}
#[test]
fn opt_1() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let stmts = tester
.parse_stmts(
"actual1.js",
"
var foo = 1;
{
const foo = 2;
{
foo = foo + foo
}
}
",
)?
.fold_with(&mut OnceMarker::new(&[(
"foo",
&[mark1, mark2, mark1, mark2, mark1],
)]));
Ok(stmts)
},
"
var foo = 1;
{
const foo1 = 2;
{
foo = foo1 + foo
}
}
",
);
}
#[test]
fn opt_2() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let mark3 = Mark::fresh(Mark::root());
let mark4 = Mark::fresh(Mark::root());
let stmts = tester
.parse_stmts(
"actual1.js",
"
var b = 1;
var b1 = 2;
{
const b = 3;
const b1 = 4;
{
b1 = b + b + b1 + b1
}
}
",
)?
.fold_with(&mut OnceMarker::new(&[
("b", &[mark1, mark2, mark2, mark1]),
("b1", &[mark3, mark4, mark3, mark4, mark3]),
]));
Ok(stmts)
},
"
var b = 1;
var b1 = 2;
{
const b2 = 3;
const b11 = 4;
{
b1 = b2 + b + b11 + b1;
}
}
",
);
}
#[test]
fn opt_3() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let stmts = tester
.parse_stmts(
"actual1.js",
"
var e = 1;
try {
throw 2;
} catch (e) {
console.log(e);
}
",
)?
.fold_with(&mut OnceMarker::new(&[("e", &[mark1, mark2, mark1])]));
Ok(stmts)
},
"
var e = 1;
try {
throw 2;
} catch (e1) {
console.log(e);
}
",
);
}
#[test]
fn opt_4() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let stmts = tester
.parse_stmts(
"actual1.js",
"
const obj = {
key: function a() {
a()
}
}
function a() {
}
",
)?
.fold_with(&mut OnceMarker::new(&[("a", &[mark1, mark2, mark2])]));
Ok(stmts)
},
"
const obj = {
key: function a1() {
a()
}
}
function a() {
}
",
);
}
#[test]
fn opt_5() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let stmts = tester
.parse_stmts(
"actual1.js",
"
const obj = {
a: function a() {
a()
}
}
function a() {
}
",
)?
.fold_with(&mut OnceMarker::new(&[("a", &[mark1, mark2, mark2])]));
Ok(stmts)
},
"
const obj = {
a: function a1() {
a()
}
}
function a() {
}
",
);
}
#[test]
fn opt_6() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let stmts = tester
.parse_stmts(
"actual1.js",
"
var foo = 'bar';
var Foo = function() {
function Foo() {
_bar.set(this, {
writable: true,
value: foo
});
var foo = 'foo';
}
}
",
)?
.fold_with(&mut OnceMarker::new(&[("foo", &[mark1, mark1, mark2])]));
Ok(stmts)
},
"
var foo = 'bar';
var Foo = function() {
function Foo() {
_bar.set(this, {
writable: true,
value: foo
});
var foo1 = 'foo';
}
}
",
);
}
#[test]
fn issue_2211_1() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let stmts = tester
.parse_stmts(
"actual1.js",
"
var _bar = require('./bar');
const makeX = ()=>{
const _bar = ()=>(0, _bar).bar()
;
return {
_bar
};
};
",
)?
.fold_with(&mut OnceMarker::new(&[(
"_bar",
&[mark1, mark2, mark1, mark2],
)]));
Ok(stmts)
},
"
var _bar = require('./bar');
const makeX = ()=>{
const _bar1 = ()=>(0, _bar).bar()
;
return {
_bar: _bar1
};
};
",
);
}
#[test]
fn issue_2211_2() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let stmts = tester
.parse_stmts(
"actual1.js",
"
var _bar = require('./bar');
const makeX = ()=>{
const _bar = () => _bar();
const alfa = () => _bar();
return { alfa };
};
",
)?
.fold_with(&mut OnceMarker::new(&[(
"_bar",
&[mark1, mark2, mark1, mark2],
)]));
Ok(stmts)
},
"
var _bar = require('./bar');
const makeX = ()=>{
const _bar1 = ()=>_bar();
const alfa = ()=>_bar1();
return {
alfa
};
};
",
);
}
#[test]
fn issue_2297_1() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let stmts = tester
.parse_stmts(
"actual1.js",
"
var _bar = require('./Bar');
var makeX = function(props) {
var _bar = props.bar;
var list = _bar.list;
return list.map(function() {
return _bar.bar;
});
};
",
)?
.fold_with(&mut OnceMarker::new(&[(
"_bar",
&[mark1, mark2, mark2, mark1],
)]));
Ok(stmts)
},
"
var _bar = require('./Bar');
var makeX = function(props) {
var _bar1 = props.bar;
var list = _bar1.list;
return list.map(function() {
return _bar.bar;
});
};
",
);
}
/// `var` has strange scoping rule.
#[test]
fn var_awareness_1() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let stmts = tester
.parse_stmts(
"actual1.js",
"
for (var i of [1, 2, 3]) {
for (var i of [4, 5, 6]) {
console.log(i)
}
}
",
)?
.fold_with(&mut OnceMarker::new(&[("i", &[mark1, mark2, mark2])]));
Ok(stmts)
},
"
for (var i of [1, 2, 3]) {
for (var i1 of [4, 5, 6]) {
console.log(i1)
}
}
",
);
}
/// `var` has strange scoping rule.
#[test]
fn var_awareness_2() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let stmts = tester
.parse_stmts(
"actual1.js",
"
for (var i of [1, 2, 3]) {
}
for (var i of [4, 5, 6]) {
console.log(i)
}
",
)?
.fold_with(&mut OnceMarker::new(&[("i", &[mark1, mark2, mark2])]));
Ok(stmts)
},
"
for (var i of [1, 2, 3]) {
}
for (var i1 of [4, 5, 6]) {
console.log(i1)
}
",
);
}
/// `var` has strange scoping rule.
#[test]
fn issue_2539() {
test(
|tester| {
let mark1 = Mark::fresh(Mark::root());
let mark2 = Mark::fresh(Mark::root());
let stmts = tester
.parse_stmts(
"actual1.js",
"
const obj = {
foo: {
func1(index) {
},
func2(index, index1) {
},
},
}
",
)?
.fold_with(&mut OnceMarker::new(&[("index", &[mark1, mark2])]));
Ok(stmts)
},
"
const obj = {
foo: {
func1(index) {
},
func2(index, index1) {
},
},
}
",
);
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/lib.rs | Rust | // #![cfg_attr(test, deny(warnings))]
#![allow(clippy::mutable_key_type)]
#![cfg_attr(not(test), allow(unused))]
pub use self::resolver::resolver;
#[doc(hidden)]
pub mod ext;
pub mod fixer;
#[macro_use]
pub mod hygiene;
pub mod assumptions;
pub mod feature;
pub mod helpers;
#[doc(hidden)]
pub mod native;
pub mod perf;
pub mod quote;
pub mod rename;
mod resolver;
pub mod scope;
#[cfg(test)]
mod tests;
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/native.rs | Rust | //! Module to check if an identifier is native word.
use phf::phf_set;
macro_rules! native {
(
$(
$i:tt
),*
) => {
/// Is `sym` a native **class**?
pub fn is_native(sym: &str) -> bool {
static SET: phf::Set<&'static str> = phf_set! {
$(
$i,
)*
};
SET.contains(sym)
}
};
}
native!(
"Array",
"ArrayBuffer",
"Atomics",
"BigInt",
"BigInt64Array",
"BigUint64Array",
"Boolean",
"DataView",
"Date",
"Error",
"EvalError",
"Float32Array",
"Float64Array",
"Function",
"Infinity",
"Int16Array",
"Int32Array",
"Int8Array",
"JSON",
"Map",
"Math",
"Number",
"Object",
"Promise",
"Proxy",
"RangeError",
"ReferenceError",
"Reflect",
"RegExp",
"Set",
"SharedArrayBuffer",
"String",
"Symbol",
"SyntaxError",
"TypeError",
"Uint16Array",
"Uint32Array",
"Uint8Array",
"Uint8ClampedArray",
"URIError",
"WeakMap",
"WeakSet",
"AbortController",
"AbortSignal",
"AnalyserNode",
"Animation",
"AnimationEffectReadOnly",
"AnimationEffectTiming",
"AnimationEffectTimingReadOnly",
"AnimationEvent",
"AnimationPlaybackEvent",
"AnimationTimeline",
"ApplicationCache",
"ApplicationCacheErrorEvent",
"Attr",
"Audio",
"AudioBuffer",
"AudioBufferSourceNode",
"AudioContext",
"AudioDestinationNode",
"AudioListener",
"AudioNode",
"AudioParam",
"AudioProcessingEvent",
"AudioScheduledSourceNode",
"AudioWorkletGlobalScope",
"AudioWorkletNode",
"AudioWorkletProcessor",
"BarProp",
"BaseAudioContext",
"BatteryManager",
"BeforeUnloadEvent",
"BiquadFilterNode",
"Blob",
"BlobEvent",
"BroadcastChannel",
"BudgetService",
"ByteLengthQueuingStrategy",
"Cache",
"CacheStorage",
"CanvasCaptureMediaStreamTrack",
"CanvasGradient",
"CanvasPattern",
"CanvasRenderingContext2D",
"ChannelMergerNode",
"ChannelSplitterNode",
"CharacterData",
"ClipboardEvent",
"CloseEvent",
"Comment",
"CompositionEvent",
"ConstantSourceNode",
"ConvolverNode",
"CountQueuingStrategy",
"Credential",
"CredentialsContainer",
"Crypto",
"CryptoKey",
"CSS",
"CSSConditionRule",
"CSSFontFaceRule",
"CSSGroupingRule",
"CSSImportRule",
"CSSKeyframeRule",
"CSSKeyframesRule",
"CSSMediaRule",
"CSSNamespaceRule",
"CSSPageRule",
"CSSRule",
"CSSRuleList",
"CSSStyleDeclaration",
"CSSStyleRule",
"CSSStyleSheet",
"CSSSupportsRule",
"CustomElementRegistry",
"CustomEvent",
"DataTransfer",
"DataTransferItem",
"DataTransferItemList",
"DelayNode",
"DeviceMotionEvent",
"DeviceOrientationEvent",
"Document",
"DocumentFragment",
"DocumentType",
"DOMError",
"DOMException",
"DOMImplementation",
"DOMMatrix",
"DOMMatrixReadOnly",
"DOMParser",
"DOMPoint",
"DOMPointReadOnly",
"DOMQuad",
"DOMRect",
"DOMRectReadOnly",
"DOMStringList",
"DOMStringMap",
"DOMTokenList",
"DragEvent",
"DynamicsCompressorNode",
"Element",
"ErrorEvent",
"Event",
"EventSource",
"EventTarget",
"File",
"FileList",
"FileReader",
"FocusEvent",
"FontFace",
"FontFaceSetLoadEvent",
"FormData",
"GainNode",
"Gamepad",
"GamepadButton",
"GamepadEvent",
"HashChangeEvent",
"Headers",
"History",
"HTMLAllCollection",
"HTMLAnchorElement",
"HTMLAreaElement",
"HTMLAudioElement",
"HTMLBaseElement",
"HTMLBodyElement",
"HTMLBRElement",
"HTMLButtonElement",
"HTMLCanvasElement",
"HTMLCollection",
"HTMLContentElement",
"HTMLDataElement",
"HTMLDataListElement",
"HTMLDetailsElement",
"HTMLDialogElement",
"HTMLDirectoryElement",
"HTMLDivElement",
"HTMLDListElement",
"HTMLDocument",
"HTMLElement",
"HTMLEmbedElement",
"HTMLFieldSetElement",
"HTMLFontElement",
"HTMLFormControlsCollection",
"HTMLFormElement",
"HTMLFrameElement",
"HTMLFrameSetElement",
"HTMLHeadElement",
"HTMLHeadingElement",
"HTMLHRElement",
"HTMLHtmlElement",
"HTMLIFrameElement",
"HTMLImageElement",
"HTMLInputElement",
"HTMLLabelElement",
"HTMLLegendElement",
"HTMLLIElement",
"HTMLLinkElement",
"HTMLMapElement",
"HTMLMarqueeElement",
"HTMLMediaElement",
"HTMLMenuElement",
"HTMLMetaElement",
"HTMLMeterElement",
"HTMLModElement",
"HTMLObjectElement",
"HTMLOListElement",
"HTMLOptGroupElement",
"HTMLOptionElement",
"HTMLOptionsCollection",
"HTMLOutputElement",
"HTMLParagraphElement",
"HTMLParamElement",
"HTMLPictureElement",
"HTMLPreElement",
"HTMLProgressElement",
"HTMLQuoteElement",
"HTMLScriptElement",
"HTMLSelectElement",
"HTMLShadowElement",
"HTMLSlotElement",
"HTMLSourceElement",
"HTMLSpanElement",
"HTMLStyleElement",
"HTMLTableCaptionElement",
"HTMLTableCellElement",
"HTMLTableColElement",
"HTMLTableElement",
"HTMLTableRowElement",
"HTMLTableSectionElement",
"HTMLTemplateElement",
"HTMLTextAreaElement",
"HTMLTimeElement",
"HTMLTitleElement",
"HTMLTrackElement",
"HTMLUListElement",
"HTMLUnknownElement",
"HTMLVideoElement",
"IDBCursor",
"IDBCursorWithValue",
"IDBDatabase",
"IDBFactory",
"IDBIndex",
"IDBKeyRange",
"IDBObjectStore",
"IDBOpenDBRequest",
"IDBRequest",
"IDBTransaction",
"IDBVersionChangeEvent",
"IdleDeadline",
"IIRFilterNode",
"Image",
"ImageBitmap",
"ImageBitmapRenderingContext",
"ImageCapture",
"ImageData",
"InputEvent",
"IntersectionObserver",
"IntersectionObserverEntry",
"Intl",
"KeyboardEvent",
"KeyframeEffect",
"KeyframeEffectReadOnly",
"Location",
"MediaDeviceInfo",
"MediaDevices",
"MediaElementAudioSourceNode",
"MediaEncryptedEvent",
"MediaError",
"MediaKeyMessageEvent",
"MediaKeySession",
"MediaKeyStatusMap",
"MediaKeySystemAccess",
"MediaList",
"MediaQueryList",
"MediaQueryListEvent",
"MediaRecorder",
"MediaSettingsRange",
"MediaSource",
"MediaStream",
"MediaStreamAudioDestinationNode",
"MediaStreamAudioSourceNode",
"MediaStreamEvent",
"MediaStreamTrack",
"MediaStreamTrackEvent",
"MessageChannel",
"MessageEvent",
"MessagePort",
"MIDIAccess",
"MIDIConnectionEvent",
"MIDIInput",
"MIDIInputMap",
"MIDIMessageEvent",
"MIDIOutput",
"MIDIOutputMap",
"MIDIPort",
"MimeType",
"MimeTypeArray",
"MouseEvent",
"MutationEvent",
"MutationObserver",
"MutationRecord",
"NamedNodeMap",
"NavigationPreloadManager",
"Navigator",
"NetworkInformation",
"Node",
"NodeFilter",
"NodeIterator",
"NodeList",
"Notification",
"OfflineAudioCompletionEvent",
"OfflineAudioContext",
"OffscreenCanvas",
"Option",
"OscillatorNode",
"PageTransitionEvent",
"PannerNode",
"Path2D",
"PaymentAddress",
"PaymentRequest",
"PaymentRequestUpdateEvent",
"PaymentResponse",
"Performance",
"PerformanceEntry",
"PerformanceLongTaskTiming",
"PerformanceMark",
"PerformanceMeasure",
"PerformanceNavigation",
"PerformanceNavigationTiming",
"PerformanceObserver",
"PerformanceObserverEntryList",
"PerformancePaintTiming",
"PerformanceResourceTiming",
"PerformanceTiming",
"PeriodicWave",
"Permissions",
"PermissionStatus",
"PhotoCapabilities",
"Plugin",
"PluginArray",
"PointerEvent",
"PopStateEvent",
"Presentation",
"PresentationAvailability",
"PresentationConnection",
"PresentationConnectionAvailableEvent",
"PresentationConnectionCloseEvent",
"PresentationConnectionList",
"PresentationReceiver",
"PresentationRequest",
"ProcessingInstruction",
"ProgressEvent",
"PromiseRejectionEvent",
"PushManager",
"PushSubscription",
"PushSubscriptionOptions",
"RadioNodeList",
"Range",
"ReadableStream",
"RemotePlayback",
"Request",
"ResizeObserver",
"ResizeObserverEntry",
"Response",
"RTCCertificate",
"RTCDataChannel",
"RTCDataChannelEvent",
"RTCDtlsTransport",
"RTCIceCandidate",
"RTCIceGatherer",
"RTCIceTransport",
"RTCPeerConnection",
"RTCPeerConnectionIceEvent",
"RTCRtpContributingSource",
"RTCRtpReceiver",
"RTCRtpSender",
"RTCSctpTransport",
"RTCSessionDescription",
"RTCStatsReport",
"RTCTrackEvent",
"Screen",
"ScreenOrientation",
"ScriptProcessorNode",
"SecurityPolicyViolationEvent",
"Selection",
"ServiceWorker",
"ServiceWorkerContainer",
"ServiceWorkerRegistration",
"ShadowRoot",
"SharedWorker",
"SourceBuffer",
"SourceBufferList",
"SpeechSynthesisEvent",
"SpeechSynthesisUtterance",
"StaticRange",
"StereoPannerNode",
"Storage",
"StorageEvent",
"StorageManager",
"StyleSheet",
"StyleSheetList",
"SubtleCrypto",
"SVGAElement",
"SVGAngle",
"SVGAnimatedAngle",
"SVGAnimatedBoolean",
"SVGAnimatedEnumeration",
"SVGAnimatedInteger",
"SVGAnimatedLength",
"SVGAnimatedLengthList",
"SVGAnimatedNumber",
"SVGAnimatedNumberList",
"SVGAnimatedPreserveAspectRatio",
"SVGAnimatedRect",
"SVGAnimatedString",
"SVGAnimatedTransformList",
"SVGAnimateElement",
"SVGAnimateMotionElement",
"SVGAnimateTransformElement",
"SVGAnimationElement",
"SVGCircleElement",
"SVGClipPathElement",
"SVGComponentTransferFunctionElement",
"SVGDefsElement",
"SVGDescElement",
"SVGDiscardElement",
"SVGElement",
"SVGEllipseElement",
"SVGFEBlendElement",
"SVGFEColorMatrixElement",
"SVGFEComponentTransferElement",
"SVGFECompositeElement",
"SVGFEConvolveMatrixElement",
"SVGFEDiffuseLightingElement",
"SVGFEDisplacementMapElement",
"SVGFEDistantLightElement",
"SVGFEDropShadowElement",
"SVGFEFloodElement",
"SVGFEFuncAElement",
"SVGFEFuncBElement",
"SVGFEFuncGElement",
"SVGFEFuncRElement",
"SVGFEGaussianBlurElement",
"SVGFEImageElement",
"SVGFEMergeElement",
"SVGFEMergeNodeElement",
"SVGFEMorphologyElement",
"SVGFEOffsetElement",
"SVGFEPointLightElement",
"SVGFESpecularLightingElement",
"SVGFESpotLightElement",
"SVGFETileElement",
"SVGFETurbulenceElement",
"SVGFilterElement",
"SVGForeignObjectElement",
"SVGGElement",
"SVGGeometryElement",
"SVGGradientElement",
"SVGGraphicsElement",
"SVGImageElement",
"SVGLength",
"SVGLengthList",
"SVGLinearGradientElement",
"SVGLineElement",
"SVGMarkerElement",
"SVGMaskElement",
"SVGMatrix",
"SVGMetadataElement",
"SVGMPathElement",
"SVGNumber",
"SVGNumberList",
"SVGPathElement",
"SVGPatternElement",
"SVGPoint",
"SVGPointList",
"SVGPolygonElement",
"SVGPolylineElement",
"SVGPreserveAspectRatio",
"SVGRadialGradientElement",
"SVGRect",
"SVGRectElement",
"SVGScriptElement",
"SVGSetElement",
"SVGStopElement",
"SVGStringList",
"SVGStyleElement",
"SVGSVGElement",
"SVGSwitchElement",
"SVGSymbolElement",
"SVGTextContentElement",
"SVGTextElement",
"SVGTextPathElement",
"SVGTextPositioningElement",
"SVGTitleElement",
"SVGTransform",
"SVGTransformList",
"SVGTSpanElement",
"SVGUnitTypes",
"SVGUseElement",
"SVGViewElement",
"TaskAttributionTiming",
"Text",
"TextDecoder",
"TextEncoder",
"TextEvent",
"TextMetrics",
"TextTrack",
"TextTrackCue",
"TextTrackCueList",
"TextTrackList",
"TimeRanges",
"Touch",
"TouchEvent",
"TouchList",
"TrackEvent",
"TransitionEvent",
"TreeWalker",
"UIEvent",
"URL",
"URLSearchParams",
"ValidityState",
"VisualViewport",
"VTTCue",
"WaveShaperNode",
"WebAssembly",
"WebGL2RenderingContext",
"WebGLActiveInfo",
"WebGLBuffer",
"WebGLContextEvent",
"WebGLFramebuffer",
"WebGLProgram",
"WebGLQuery",
"WebGLRenderbuffer",
"WebGLRenderingContext",
"WebGLSampler",
"WebGLShader",
"WebGLShaderPrecisionFormat",
"WebGLSync",
"WebGLTexture",
"WebGLTransformFeedback",
"WebGLUniformLocation",
"WebGLVertexArrayObject",
"WebSocket",
"WheelEvent",
"Window",
"Worker",
"WritableStream",
"XMLDocument",
"XMLHttpRequest",
"XMLHttpRequestEventTarget",
"XMLHttpRequestUpload",
"XMLSerializer",
"XPathEvaluator",
"XPathExpression",
"XPathResult",
"XSLTProcessor"
);
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University | |
crates/swc_ecma_transforms_base/src/perf.rs | Rust | use swc_common::util::move_map::MoveMap;
#[cfg(feature = "concurrent")]
use swc_common::{errors::HANDLER, GLOBALS};
use swc_ecma_ast::*;
pub use swc_ecma_utils::parallel::*;
use swc_ecma_visit::{Fold, FoldWith, Visit, VisitMut, VisitMutWith, VisitWith};
use crate::helpers::Helpers;
#[cfg(feature = "concurrent")]
use crate::helpers::HELPERS;
pub trait Check: Visit + Default {
fn should_handle(&self) -> bool;
}
pub fn should_work<C, T>(n: &T) -> bool
where
C: Check,
T: VisitWith<C>,
{
let mut checker = C::default();
n.visit_with(&mut checker);
checker.should_handle()
}
pub trait ParExplode: Parallel {
/// Invoked after visiting each statements.
///
/// Implementor should not delete/prepend to `stmts`.
fn after_one_stmt(&mut self, stmts: &mut Vec<Stmt>);
/// Invoked after visiting each statements.
///
/// Implementor should not delete/prepend to `stmts`.
fn after_one_module_item(&mut self, stmts: &mut Vec<ModuleItem>);
}
pub trait ParVisit: Visit + Parallel {
fn visit_par<N>(&mut self, threshold: usize, nodes: &[N])
where
N: Send + Sync + VisitWith<Self>;
}
#[cfg(feature = "concurrent")]
impl<T> ParVisit for T
where
T: Visit + Parallel,
{
fn visit_par<N>(&mut self, threshold: usize, nodes: &[N])
where
N: Send + Sync + VisitWith<Self>,
{
if nodes.len() >= threshold {
HELPERS.with(|helpers| {
let helpers = helpers.data();
HANDLER.with(|handler| {
self.maybe_par(threshold, nodes, |visitor, node| {
let helpers = Helpers::from_data(helpers);
HELPERS.set(&helpers, || {
HANDLER.set(handler, || {
node.visit_with(visitor);
});
});
});
})
});
return;
}
for n in nodes {
n.visit_with(self);
}
}
}
pub trait ParVisitMut: VisitMut + Parallel {
fn visit_mut_par<N>(&mut self, threshold: usize, nodes: &mut [N])
where
N: Send + Sync + VisitMutWith<Self>;
}
#[cfg(feature = "concurrent")]
impl<T> ParVisitMut for T
where
T: VisitMut + Parallel,
{
fn visit_mut_par<N>(&mut self, threshold: usize, nodes: &mut [N])
where
N: Send + Sync + VisitMutWith<Self>,
{
if nodes.len() >= threshold {
HELPERS.with(|helpers| {
let helpers = helpers.data();
HANDLER.with(|handler| {
self.maybe_par(threshold, nodes, |visitor, node| {
let helpers = Helpers::from_data(helpers);
HELPERS.set(&helpers, || {
HANDLER.set(handler, || {
node.visit_mut_with(visitor);
});
});
});
})
});
return;
}
for n in nodes {
n.visit_mut_with(self);
}
}
}
pub trait ParFold: Fold + Parallel {
fn fold_par<N>(&mut self, threshold: usize, nodes: Vec<N>) -> Vec<N>
where
N: Send + Sync + FoldWith<Self>;
}
#[cfg(feature = "concurrent")]
impl<T> ParFold for T
where
T: Fold + Parallel,
{
fn fold_par<N>(&mut self, threshold: usize, nodes: Vec<N>) -> Vec<N>
where
N: Send + Sync + FoldWith<Self>,
{
if nodes.len() >= threshold {
use rayon::prelude::*;
let (visitor, nodes) = GLOBALS.with(|globals| {
HELPERS.with(|helpers| {
let helpers = helpers.data();
HANDLER.with(|handler| {
nodes
.into_par_iter()
.map(|node| {
let helpers = Helpers::from_data(helpers);
GLOBALS.set(globals, || {
HELPERS.set(&helpers, || {
HANDLER.set(handler, || {
let mut visitor = Parallel::create(&*self);
let node = node.fold_with(&mut visitor);
(visitor, node)
})
})
})
})
.fold(
|| (Parallel::create(&*self), Vec::new()),
|mut a, b| {
Parallel::merge(&mut a.0, b.0);
a.1.push(b.1);
a
},
)
.reduce(
|| (Parallel::create(&*self), Vec::new()),
|mut a, b| {
Parallel::merge(&mut a.0, b.0);
a.1.extend(b.1);
a
},
)
})
})
});
Parallel::merge(self, visitor);
return nodes;
}
nodes.move_map(|n| n.fold_with(self))
}
}
#[cfg(not(feature = "concurrent"))]
impl<T> ParVisit for T
where
T: Visit + Parallel,
{
fn visit_par<N>(&mut self, _: usize, nodes: &[N])
where
N: Send + Sync + VisitWith<Self>,
{
for n in nodes {
n.visit_with(self);
}
}
}
#[cfg(not(feature = "concurrent"))]
impl<T> ParVisitMut for T
where
T: VisitMut + Parallel,
{
fn visit_mut_par<N>(&mut self, _: usize, nodes: &mut [N])
where
N: Send + Sync + VisitMutWith<Self>,
{
for n in nodes {
n.visit_mut_with(self);
}
}
}
#[cfg(not(feature = "concurrent"))]
impl<T> ParFold for T
where
T: Fold + Parallel,
{
fn fold_par<N>(&mut self, _: usize, nodes: Vec<N>) -> Vec<N>
where
N: Send + Sync + FoldWith<Self>,
{
nodes.move_map(|n| n.fold_with(self))
}
}
| willcrichton/ilc-swc | 1 | Rust | willcrichton | Will Crichton | Brown University |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.