Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-06 14:10:11 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update web-platform-tests to revision 4f397167b4ed552a02201c92d363cfaecfe2c7f0

Browse source
This commit is contained in:
WPT Sync Bot 2018-04-26 21:09:36 -04:00 • committed by Anthony Ramine
parent 73b5bf201f
commit 84b40513c3
182 changed files with 4779 additions and 1937 deletions
Download patch file Download diff file Expand all files Collapse all files

289
tests/wpt/web-platform-tests/resources/webidl2/lib/writer.js
View file

@ -1,78 +1,71 @@
(function() {
"use strict";
var write = function(ast, opt) {
var curPea = "",
curTPea = "",
opt = opt || {},
noop = function(str) {
return str; },
optNames = "type".split(" "),
context = [];
for (var i = 0, n = optNames.length; i < n; i++) {
var o = optNames[i];
(() => {
function write(ast, opt = {}) {
let curPea = "";
let curTPea = "";
const noop = str => str;
const optNames = "type".split(" ");
const context = [];
for (const o of optNames) {
if (!opt[o]) opt[o] = noop;
}
var literal = function(it) {
function literal(it) {
return it.value;
};
var wsPea = function(it) {
function wsPea(it) {
curPea += it.value;
return "";
};
var wsTPea = function(it) {
function wsTPea(it) {
curTPea += it.value;
return "";
};
var lineComment = function(it) {
return "//" + it.value + "\n";
function lineComment(it) {
return `//${it.value}\n`;
};
var multilineComment = function(it) {
return "/*" + it.value + "*/";
function multilineComment(it) {
return `/*${it.value}*/`;
};
var type = function(it) {
function type(it) {
if (typeof it === "string") return opt.type(it); // XXX should maintain some context
if (it.union) return "(" + it.idlType.map(type).join(" or ") + ")";
var ret = "";
if (it.generic) ret += it.generic + "<";
else if (it.sequence) ret += "sequence<";
if (Array.isArray(it.idlType)) ret += it.idlType.map(type).join(", ");
else ret += type(it.idlType);
if (it.array || it.generic === 'Array') {
for (var i = 0, n = it.nullableArray.length; i < n; i++) {
var val = it.nullableArray[i];
if (val) ret += "?";
ret += "[]";
}
let ret = extended_attributes(it.extAttrs, curPea);
if (it.union) ret += `(${it.idlType.map(type).join(" or ")})`;
else {
if (it.generic) ret += `${it.generic}<`;
if (Array.isArray(it.idlType)) ret += it.idlType.map(type).join(", ");
else ret += type(it.idlType);
if (it.generic) ret += ">";
}
if (it.generic || it.sequence) ret += ">";
if (it.nullable) ret += "?";
return ret;
};
var const_value = function(it) {
var tp = it.type;
function const_value(it) {
const tp = it.type;
if (tp === "boolean") return it.value ? "true" : "false";
else if (tp === "null") return "null";
else if (tp === "Infinity") return (it.negative ? "-" : "") + "Infinity";
else if (tp === "NaN") return "NaN";
else if (tp === "number") return it.value;
else return '"' + it.value + '"';
else if (tp === "sequence") return "[]";
else return `"${it.value}"`;
};
var argument = function(arg, pea) {
var ret = extended_attributes(arg.extAttrs, pea);
function argument(arg, pea) {
let ret = extended_attributes(arg.extAttrs, pea);
if (arg.optional) ret += "optional ";
ret += type(arg.idlType);
if (arg.variadic) ret += "...";
ret += " " + arg.name;
if (arg["default"]) ret += " = " + const_value(arg["default"]);
ret += ` ${arg.name}`;
if (arg["default"]) ret += ` = ${const_value(arg["default"])}`;
return ret;
};
var args = function(its) {
var res = "",
pea = "";
for (var i = 0, n = its.length; i < n; i++) {
var arg = its[i];
function args(its) {
let res = "";
let pea = "";
for (let i = 0, n = its.length; i < n; i++) {
const arg = its[i];
if (arg.type === "ws") res += arg.value;
else if (arg.type === "ws-pea") pea += arg.value;
else {
@ -83,182 +76,198 @@
}
return res;
};
var make_ext_at = function(it) {
if (it["arguments"] === null) return it.name;
function make_ext_at(it) {
context.unshift(it);
var ret = it.name + "(" + (it["arguments"].length ? args(it["arguments"]) : "") + ")";
let ret = it.name;
if (it.rhs) {
if (it.rhs.type === "identifier-list") ret += `=(${it.rhs.value.join(',')})`;
else ret += `=${it.rhs.value}`;
}
if (it.arguments) ret += `(${it["arguments"].length ? args(it["arguments"]) : ""})`;
context.shift(); // XXX need to add more contexts, but not more than needed for ReSpec
return ret;
};
var extended_attributes = function(eats, pea) {
function extended_attributes(eats, pea) {
if (!eats || !eats.length) return "";
return "[" + eats.map(make_ext_at).join(", ") + "]" + pea;
return `[${eats.map(make_ext_at).join(", ")}]${pea}`;
};
var modifiers = "getter setter creator deleter legacycaller stringifier static".split(" ");
var operation = function(it) {
var ret = extended_attributes(it.extAttrs, curPea);
const modifiers = "getter setter creator deleter legacycaller stringifier static".split(" ");
function operation(it) {
let ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
if (it.stringifier && !it.idlType) return "stringifier;";
for (var i = 0, n = modifiers.length; i < n; i++) {
var mod = modifiers[i];
for (const mod of modifiers) {
if (it[mod]) ret += mod + " ";
}
ret += type(it.idlType) + " ";
if (it.name) ret += it.name;
ret += "(" + args(it["arguments"]) + ");";
ret += `(${args(it["arguments"])});`;
return ret;
};
var attribute = function(it) {
var ret = extended_attributes(it.extAttrs, curPea);
function attribute(it) {
let ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
if (it["static"]) ret += "static ";
if (it.stringifier) ret += "stringifier ";
if (it.readonly) ret += "readonly ";
if (it.inherit) ret += "inherit ";
ret += "attribute " + type(it.idlType) + " " + it.name + ";";
ret += `attribute ${type(it.idlType)} ${it.name};`;
return ret;
};
var interface_ = function(it) {
var ret = extended_attributes(it.extAttrs, curPea);
function interface_(it) {
let ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
if (it.partial) ret += "partial ";
ret += "interface " + it.name + " ";
if (it.inheritance) ret += ": " + it.inheritance + " ";
ret += "{" + iterate(it.members) + "};";
ret += `interface ${it.name} `;
if (it.inheritance) ret += `: ${it.inheritance} `;
ret += `{${iterate(it.members)}};`;
return ret;
};
var dictionary = function(it) {
var ret = extended_attributes(it.extAttrs, curPea);
function interface_mixin(it) {
let ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
if (it.partial) ret += "partial ";
ret += "dictionary " + it.name + " ";
ret += "{" + iterate(it.members) + "};";
ret += `interface mixin ${it.name} `;
ret += `{${iterate(it.members)}};`;
return ret;
}
function namespace(it) {
let ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
if (it.partial) ret += "partial ";
ret += `namespace ${it.name} `;
ret += `{${iterate(it.members)}};`;
return ret;
}
function dictionary(it) {
let ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
if (it.partial) ret += "partial ";
ret += `dictionary ${it.name} `;
if (it.inheritance) ret += `: ${it.inheritance} `;
ret += `{${iterate(it.members)}};`;
return ret;
};
var field = function(it) {
var ret = extended_attributes(it.extAttrs, curPea);
function field(it) {
let ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
if (it.required) ret += "required ";
ret += type(it.idlType) + " " + it.name;
if (it["default"]) ret += " = " + const_value(it["default"]);
ret += `${type(it.idlType)} ${it.name}`;
if (it["default"]) ret += ` = ${const_value(it["default"])}`;
ret += ";";
return ret;
};
var exception = function(it) {
var ret = extended_attributes(it.extAttrs, curPea);
function const_(it) {
const ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
ret += "exception " + it.name + " ";
if (it.inheritance) ret += ": " + it.inheritance + " ";
ret += "{" + iterate(it.members) + "};";
return ret;
return `${ret}const ${type(it.idlType)}${it.nullable ? "?" : ""} ${it.name} = ${const_value(it.value)};`;
};
var const_ = function(it) {
var ret = extended_attributes(it.extAttrs, curPea);
function typedef(it) {
let ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
return ret + "const " + type(it.idlType) + " " + it.name + " = " + const_value(it.value) + ";";
};
var typedef = function(it) {
var ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
ret += "typedef " + extended_attributes(it.typeExtAttrs, curTPea);
ret += `typedef ${extended_attributes(it.typeExtAttrs, curTPea)}`;
curTPea = "";
return ret + type(it.idlType) + " " + it.name + ";";
return `${ret}${type(it.idlType)} ${it.name};`;
};
var implements_ = function(it) {
var ret = extended_attributes(it.extAttrs, curPea);
function implements_(it) {
const ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
return ret + it.target + " implements " + it["implements"] + ";";
return `${ret}${it.target} implements ${it["implements"]};`;
};
var callback = function(it) {
var ret = extended_attributes(it.extAttrs, curPea);
function includes(it) {
const ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
return ret + "callback " + it.name + " = " + type(it.idlType) +
"(" + args(it["arguments"]) + ");";
return `${ret}${it.target} includes ${it.includes};`;
};
var enum_ = function(it) {
var ret = extended_attributes(it.extAttrs, curPea);
function callback(it) {
const ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
ret += "enum " + it.name + " {";
for (var i = 0, n = it.values.length; i < n; i++) {
var v = it.values[i];
if (typeof v === "string") ret += '"' + v + '"';
return `${ret}callback ${it.name} = ${type(it.idlType)}(${args(it["arguments"])});`;
};
function enum_(it) {
let ret = extended_attributes(it.extAttrs, curPea);
curPea = "";
ret += `enum ${it.name} {`;
for (const v of it.values) {
if (v.type === "string") ret += `"${v.value}"`;
else if (v.type === "ws") ret += v.value;
else if (v.type === ",") ret += ",";
}
return ret + "};";
};
var iterable = function(it) {
return "iterable<" + (it.idlType instanceof Array ? it.idlType.map(type).join(", ") : type(it.idlType)) + ">;";
function iterable(it) {
return `iterable<${Array.isArray(it.idlType) ? it.idlType.map(type).join(", ") : type(it.idlType)}>;`;
};
var legacyiterable = function(it) {
return "legacyiterable<" + (it.idlType instanceof Array ? it.idlType.map(type).join(", ") : type(it.idlType)) + ">;";
function legacyiterable(it) {
return `legacyiterable<${Array.isArray(it.idlType) ? it.idlType.map(type).join(", ") : type(it.idlType)}>;`;
};
var maplike = function(it) {
return (it.readonly ? "readonly " : "") + "maplike<" +
it.idlType.map(type).join(", ") + ">;";
function maplike(it) {
return `${it.readonly ? "readonly " : ""}maplike<${it.idlType.map(type).join(", ")}>;`;
};
var setlike = function(it) {
return (it.readonly ? "readonly " : "") + "setlike<" +
type(it.idlType) + ">;";
function setlike(it) {
return `${it.readonly ? "readonly " : ""}setlike<${type(it.idlType[0])}>;`;
};
var callbackInterface = function(it) {
return 'callback ' + interface_(it);
function callbackInterface(it) {
return `callback ${interface_(it)}`;
};
var table = {
const table = {
ws: literal,
"ws-pea": wsPea,
"ws-tpea": wsTPea,
"line-comment": lineComment,
"multiline-comment": multilineComment,
"interface": interface_,
operation: operation,
attribute: attribute,
dictionary: dictionary,
field: field,
exception: exception,
"const": const_,
typedef: typedef,
"implements": implements_,
callback: callback,
"enum": enum_,
iterable: iterable,
legacyiterable: legacyiterable,
maplike: maplike,
setlike: setlike,
interface: interface_,
"interface mixin": interface_mixin,
namespace,
operation,
attribute,
dictionary,
field,
const: const_,
typedef,
implements: implements_,
includes,
callback,
enum: enum_,
iterable,
legacyiterable,
maplike,
setlike,
"callback interface": callbackInterface
};
var dispatch = function(it) {
function dispatch(it) {
const dispatcher = table[it.type];
if (!dispatcher) {
throw new Error(`Type "${it.type}" is unsupported`)
}
return table[it.type](it);
};
var iterate = function(things) {
function iterate(things) {
if (!things) return;
var ret = "";
for (var i = 0, n = things.length; i < n; i++) ret += dispatch(things[i]);
let ret = "";
for (const thing of things) ret += dispatch(thing);
return ret;
};
return iterate(ast);
};
var obj = {
write: function(ast, opt) {
if (!opt) opt = {};
return write(ast, opt);
}
const obj = {
write
};
if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
module.exports = obj;
} else if (typeof define === 'function' && define.amd) {
define([], function() {
return obj;
});
define([], () => obj);
} else {
(self || window).WebIDL2Writer = obj;
}
}());
})();