mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Backed out 3 changesets (bug 927116) for Win debug XPCShell test bustage 

Backed out changeset dfeee13c85fb (bug 927116)
Backed out changeset 17b2babbe34e (bug 927116)
Backed out changeset 13f60271f4f6 (bug 927116)
This commit is contained in:
Wes Kocher 2013-11-06 12:53:11 -08:00
Родитель f34062284c
Коммит 7cbc50abf1
12 изменённых файлов: 1 добавлений и 428 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

5
js/src/frontend/BytecodeEmitter.cpp
Просмотреть файл

@ -6447,11 +6447,6 @@ frontend::EmitTree(ExclusiveContext *cx, BytecodeEmitter *bce, ParseNode *pn)
: EmitVariables(cx, bce, pn, InitializeVars);
break;
case PNK_IMPORT:
// TODO: Implement emitter support for modules
bce->reportError(nullptr, JSMSG_MODULES_NOT_IMPLEMENTED);
return false;
case PNK_ARRAYPUSH: {
int slot;

10
js/src/frontend/FullParseHandler.h
Просмотреть файл

@ -295,16 +295,6 @@ class FullParseHandler
return new_<UnaryNode>(PNK_SEMI, JSOP_NOP, pos, (ParseNode *) nullptr);
}
ParseNode *newImportDeclaration(ParseNode *importSpecSet,
ParseNode *moduleSpec, const TokenPos &pos)
{
ParseNode *pn = new_<BinaryNode>(PNK_IMPORT, JSOP_NOP, pos,
importSpecSet, moduleSpec);
if (!pn)
return null();
return pn;
}
ParseNode *newExprStatement(ParseNode *expr, uint32_t end) {
JS_ASSERT(expr->pn_pos.end <= end);
return new_<UnaryNode>(PNK_SEMI, JSOP_NOP, TokenPos(expr->pn_pos.begin, end), expr);

3
js/src/frontend/ParseNode.h
Просмотреть файл

@ -128,9 +128,6 @@ class UpvarCookie
F(ARRAYPUSH) \
F(LEXICALSCOPE) \
F(LET) \
F(IMPORT) \
F(IMPORT_SPEC_LIST) \
F(IMPORT_SPEC) \
F(SEQ) \
F(FORIN) \
F(FOROF) \

130
js/src/frontend/Parser.cpp
Просмотреть файл

@ -3628,134 +3628,6 @@ Parser<SyntaxParseHandler>::letStatement()
return SyntaxParseHandler::NodeFailure;
}
template<typename ParseHandler>
typename ParseHandler::Node
Parser<ParseHandler>::importDeclaration()
{
JS_ASSERT(tokenStream.currentToken().type == TOK_IMPORT);
if (pc->sc->isFunctionBox() || !pc->atBodyLevel()) {
report(ParseError, false, null(), JSMSG_IMPORT_DECL_AT_TOP_LEVEL);
return null();
}
uint32_t begin = pos().begin;
TokenKind tt = tokenStream.getToken();
Node importSpecSet = handler.newList(PNK_IMPORT_SPEC_LIST);
if (!importSpecSet)
return null();
if (tt == TOK_NAME || tt == TOK_LC) {
if (tt == TOK_NAME) {
// Handle the form |import a from 'b'|, by adding a single import
// specifier to the list, with 'default' as the import name and
// 'a' as the binding name. This is equivalent to
// |import { default as a } from 'b'|.
Node importName = newName(context->names().default_);
if (!importName)
return null();
Node bindingName = newName(tokenStream.currentName());
if (!bindingName)
return null();
Node importSpec = handler.newBinary(PNK_IMPORT_SPEC, importName, bindingName);
if (!importSpec)
return null();
handler.addList(importSpecSet, importSpec);
} else {
do {
// Handle the forms |import {} from 'a'| and
// |import { ..., } from 'a'| (where ... is non empty), by
// escaping the loop early if the next token is }.
tt = tokenStream.peekToken(TokenStream::KeywordIsName);
if (tt == TOK_ERROR)
return null();
if (tt == TOK_RC)
break;
// If the next token is a keyword, the previous call to
// peekToken matched it as a TOK_NAME, and put it in the
// lookahead buffer, so this call will match keywords as well.
MUST_MATCH_TOKEN(TOK_NAME, JSMSG_NO_IMPORT_NAME);
Node importName = newName(tokenStream.currentName());
if (!importName)
return null();
if (tokenStream.getToken() == TOK_NAME &&
tokenStream.currentName() == context->names().as)
{
if (tokenStream.getToken() != TOK_NAME) {
report(ParseError, false, null(), JSMSG_NO_BINDING_NAME);
return null();
}
} else {
// Keywords cannot be bound to themselves, so an import name
// that is a keyword is a syntax error if it is not followed
// by the keyword 'as'.
if (IsKeyword(importName->name())) {
JSAutoByteString bytes;
if (!AtomToPrintableString(context, importName->name(), &bytes))
return null();
report(ParseError, false, null(), JSMSG_AS_AFTER_RESERVED_WORD, bytes.ptr());
return null();
}
tokenStream.ungetToken();
}
Node bindingName = newName(tokenStream.currentName());
if (!bindingName)
return null();
Node importSpec = handler.newBinary(PNK_IMPORT_SPEC, importName, bindingName);
if (!importSpec)
return null();
handler.addList(importSpecSet, importSpec);
} while (tokenStream.matchToken(TOK_COMMA));
MUST_MATCH_TOKEN(TOK_RC, JSMSG_RC_AFTER_IMPORT_SPEC_LIST);
}
if (tokenStream.getToken() != TOK_NAME ||
tokenStream.currentName() != context->names().from)
{
report(ParseError, false, null(), JSMSG_FROM_AFTER_IMPORT_SPEC_SET);
return null();
}
MUST_MATCH_TOKEN(TOK_STRING, JSMSG_MODULE_SPEC_AFTER_FROM);
} else {
if (tt != TOK_STRING) {
report(ParseError, false, null(), JSMSG_DECLARATION_AFTER_IMPORT);
return null();
}
// Handle the form |import 'a'| by leaving the list empty. This is
// equivalent to |import {} from 'a'|.
importSpecSet->pn_pos.end = importSpecSet->pn_pos.begin;
}
Node moduleSpec = stringLiteral();
if (!moduleSpec)
return null();
if (!MatchOrInsertSemicolon(tokenStream))
return null();
return handler.newImportDeclaration(importSpecSet, moduleSpec,
TokenPos(begin, pos().end));
}
template<>
SyntaxParseHandler::Node
Parser<SyntaxParseHandler>::importDeclaration()
{
JS_ALWAYS_FALSE(abortIfSyntaxParser());
return SyntaxParseHandler::NodeFailure;
}
template <typename ParseHandler>
typename ParseHandler::Node
Parser<ParseHandler>::expressionStatement()
@ -5035,8 +4907,6 @@ Parser<ParseHandler>::statement(bool canHaveDirectives)
case TOK_LET:
return letStatement();
case TOK_IMPORT:
return importDeclaration();
case TOK_SEMI:
return handler.newEmptyStatement(pos());
case TOK_IF:

1
js/src/frontend/Parser.h
Просмотреть файл

@ -512,7 +512,6 @@ class Parser : private AutoGCRooter, public StrictModeGetter
Node debuggerStatement();
Node letStatement();
Node importDeclaration();
Node expressionStatement();
Node variables(ParseNodeKind kind, bool *psimple = nullptr,
StaticBlockObject *blockObj = nullptr,

1
js/src/jit-test/lib/match.js
Просмотреть файл

@ -1 +0,0 @@
loadRelativeToScript("../../tests/js1_8_5/extensions/shell.js");

186
js/src/jit-test/tests/modules/import-declaration.js
Просмотреть файл

@ -1,186 +0,0 @@
load(libdir + "match.js");
load(libdir + "asserts.js");
var { Pattern, MatchError } = Match;
program = (elts) => Pattern({
type: "Program",
body: elts
})
importDeclaration = (specifiers, source) => Pattern({
type: "ImportDeclaration",
specifiers: specifiers,
source: source
});
importSpecifier = (id, name) => Pattern({
type: "ImportSpecifier",
id: id,
name: name
});
ident = (name) => Pattern({
type: "Identifier",
name: name
})
lit = (val) => Pattern({
type: "Literal",
value: val
})
program([
importDeclaration(
[
importSpecifier(
ident("default"),
ident("a")
)
],
lit("b")
)
]).assert(Reflect.parse("import a from 'b'"));
program([
importDeclaration(
[],
lit("a")
)
]).assert(Reflect.parse("import {} from 'a'"));
program([
importDeclaration(
[
importSpecifier(
ident("a"),
ident("a")
)
],
lit("b")
)
]).assert(Reflect.parse("import { a } from 'b'"));
program([
importDeclaration(
[
importSpecifier(
ident("a"),
ident("a")
)
],
lit("b")
)
]).assert(Reflect.parse("import { a, } from 'b'"));
program([
importDeclaration(
[
importSpecifier(
ident("a"),
ident("b")
)
],
lit("c")
)
]).assert(Reflect.parse("import { a as b } from 'c'"));
program([
importDeclaration(
[
importSpecifier(
ident("as"),
ident("as")
)
],
lit("a")
)
]).assert(Reflect.parse("import { as as as } from 'a'"));
program([
importDeclaration(
[
importSpecifier(
ident("true"),
ident("a")
)
],
lit("b")
)
]).assert(Reflect.parse("import { true as a } from 'b'"));
program([
importDeclaration(
[
importSpecifier(
ident("a"),
ident("a")
),
importSpecifier(
ident("b"),
ident("b")
),
],
lit("c")
)
]).assert(Reflect.parse("import { a, b } from 'c'"));
program([
importDeclaration(
[
importSpecifier(
ident("a"),
ident("b")
),
importSpecifier(
ident("c"),
ident("d")
),
],
lit("e")
)
]).assert(Reflect.parse("import { a as b, c as d } from 'e'"));
program([
importDeclaration(
[],
lit("a")
)
]).assert(Reflect.parse("import 'a'"));
var loc = Reflect.parse("import { a as b } from 'c'", {
loc: true
}).body[0].loc;
assertEq(loc.start.line, 1);
assertEq(loc.start.column, 0);
assertEq(loc.start.line, 1);
assertEq(loc.end.column, 26);
assertThrowsInstanceOf(function () {
Reflect.parse("function f() { import a from 'b' }");
}, SyntaxError);
assertThrowsInstanceOf(function () {
Reflect.parse("if (true) import a from 'b'");
}, SyntaxError);
assertThrowsInstanceOf(function() {
Reflect.parse("import {");
}, SyntaxError);
assertThrowsInstanceOf(function() {
Reflect.parse("import {}");
}, SyntaxError);
assertThrowsInstanceOf(function() {
Reflect.parse("import {} from");
}, SyntaxError);
assertThrowsInstanceOf(function() {
Reflect.parse("import {,} from 'a'");
}, SyntaxError);
assertThrowsInstanceOf(function() {
Reflect.parse("import { a as true } from 'b'");
}, SyntaxError);
assertThrowsInstanceOf(function() {
Reflect.parse("import { true } from 'a'");
}, SyntaxError);

10
js/src/js.msg
Просмотреть файл

@ -417,13 +417,3 @@ MSG_DEF(JSMSG_TYPEDOBJECT_NO_SUCH_PROP, 363, 1, JSEXN_TYPEERR, "No such property
MSG_DEF(JSMSG_TYPEDOBJECT_HANDLE_BAD_ARGS, 364, 2, JSEXN_TYPEERR, "argument {0} invalid: expected {1}")
MSG_DEF(JSMSG_TYPEDOBJECT_HANDLE_UNATTACHED, 365, 0, JSEXN_TYPEERR, "handle unattached")
MSG_DEF(JSMSG_TYPEDOBJECT_HANDLE_BAD_TYPE, 366, 0, JSEXN_TYPEERR, "handle moved to destination of incorrect type")
MSG_DEF(JSMSG_IMPORT_DECL_AT_TOP_LEVEL, 367, 0, JSEXN_SYNTAXERR, "import declarations may only appear at top level")
MSG_DEF(JSMSG_NO_IMPORT_NAME, 368, 0, JSEXN_SYNTAXERR, "missing import name")
MSG_DEF(JSMSG_AS_AFTER_RESERVED_WORD, 369, 1, JSEXN_SYNTAXERR, "missing keyword 'as' after reserved word '{0}'")
MSG_DEF(JSMSG_NO_BINDING_NAME, 370, 0, JSEXN_SYNTAXERR, "missing binding name")
MSG_DEF(JSMSG_RC_AFTER_IMPORT_SPEC_LIST, 371, 0, JSEXN_SYNTAXERR, "missing '}' after module specifier list")
MSG_DEF(JSMSG_FROM_AFTER_IMPORT_SPEC_SET, 372, 0, JSEXN_SYNTAXERR, "missing keyword 'from' after import specifier set")
MSG_DEF(JSMSG_DECLARATION_AFTER_IMPORT, 373, 0, JSEXN_SYNTAXERR, "missing declaration after 'import' keyword")
MSG_DEF(JSMSG_MODULE_SPEC_AFTER_FROM, 374, 0, JSEXN_SYNTAXERR, "missing module specifier after 'from' keyword")
MSG_DEF(JSMSG_MODULES_NOT_IMPLEMENTED, 375, 0, JSEXN_SYNTAXERR, "modules are not implemented yet")

2
js/src/jsast.tbl
Просмотреть файл

@ -57,8 +57,6 @@ ASTDEF(AST_TRY_STMT, "TryStatement", "tryStatemen
ASTDEF(AST_THROW_STMT, "ThrowStatement", "throwStatement")
ASTDEF(AST_DEBUGGER_STMT, "DebuggerStatement", "debuggerStatement")
ASTDEF(AST_LET_STMT, "LetStatement", "letStatement")
ASTDEF(AST_IMPORT_DECL, "ImportDeclaration", "importDeclaration")
ASTDEF(AST_IMPORT_SPEC, "ImportSpecifier", "importSpecifier")
ASTDEF(AST_CASE, "SwitchCase", "switchCase")
ASTDEF(AST_CATCH, "CatchClause", "catchClause")

76
js/src/jsreflect.cpp
Просмотреть файл

@ -562,10 +562,6 @@ class NodeBuilder
bool letStatement(NodeVector &head, HandleValue stmt, TokenPos *pos, MutableHandleValue dst);
bool importDeclaration(NodeVector &elts, HandleValue moduleSpec, TokenPos *pos, MutableHandleValue dst);
bool importSpecifier(HandleValue importName, HandleValue bindingName, TokenPos *pos, MutableHandleValue dst);
/*
* expressions
*/
@ -1357,38 +1353,6 @@ NodeBuilder::letStatement(NodeVector &head, HandleValue stmt, TokenPos *pos, Mut
dst);
}
bool
NodeBuilder::importDeclaration(NodeVector &elts, HandleValue moduleSpec, TokenPos *pos,
MutableHandleValue dst)
{
RootedValue array(cx);
if (!newArray(elts, &array))
return false;
RootedValue cb(cx, callbacks[AST_IMPORT_DECL]);
if (!cb.isNull())
return callback(cb, array, moduleSpec, pos, dst);
return newNode(AST_IMPORT_DECL, pos,
"specifiers", array,
"source", moduleSpec,
dst);
}
bool
NodeBuilder::importSpecifier(HandleValue importName, HandleValue bindingName, TokenPos *pos,
MutableHandleValue dst)
{
RootedValue cb(cx, callbacks[AST_IMPORT_SPEC]);
if (!cb.isNull())
return callback(cb, importName, bindingName, pos, dst);
return newNode(AST_IMPORT_SPEC, pos,
"id", importName,
"name", bindingName,
dst);
}
bool
NodeBuilder::variableDeclaration(NodeVector &elts, VarDeclKind kind, TokenPos *pos,
MutableHandleValue dst)
@ -1556,8 +1520,6 @@ class ASTSerializer
bool variableDeclaration(ParseNode *pn, bool let, MutableHandleValue dst);
bool variableDeclarator(ParseNode *pn, VarDeclKind *pkind, MutableHandleValue dst);
bool let(ParseNode *pn, bool expr, MutableHandleValue dst);
bool importDeclaration(ParseNode *pn, MutableHandleValue dst);
bool importSpecifier(ParseNode *pn, MutableHandleValue dst);
bool optStatement(ParseNode *pn, MutableHandleValue dst) {
if (!pn) {
@ -1921,41 +1883,6 @@ ASTSerializer::let(ParseNode *pn, bool expr, MutableHandleValue dst)
builder.letStatement(dtors, v, &pn->pn_pos, dst);
}
bool
ASTSerializer::importDeclaration(ParseNode *pn, MutableHandleValue dst)
{
JS_ASSERT(pn->isKind(PNK_IMPORT));
JS_ASSERT(pn->pn_left->isKind(PNK_IMPORT_SPEC_LIST));
JS_ASSERT(pn->pn_right->isKind(PNK_STRING));
NodeVector elts(cx);
if (!elts.reserve(pn->pn_count))
return false;
for (ParseNode *next = pn->pn_left->pn_head; next; next = next->pn_next) {
RootedValue elt(cx);
if (!importSpecifier(next, &elt))
return false;
elts.infallibleAppend(elt);
}
RootedValue moduleSpec(cx);
return literal(pn->pn_right, &moduleSpec) &&
builder.importDeclaration(elts, moduleSpec, &pn->pn_pos, dst);
}
bool
ASTSerializer::importSpecifier(ParseNode *pn, MutableHandleValue dst)
{
JS_ASSERT(pn->isKind(PNK_IMPORT_SPEC));
RootedValue importName(cx);
RootedValue bindingName(cx);
return identifier(pn->pn_left, &importName) &&
identifier(pn->pn_right, &bindingName) &&
builder.importSpecifier(importName, bindingName, &pn->pn_pos, dst);
}
bool
ASTSerializer::switchCase(ParseNode *pn, MutableHandleValue dst)
{
@ -2111,9 +2038,6 @@ ASTSerializer::statement(ParseNode *pn, MutableHandleValue dst)
? let(pn, false, dst)
: declaration(pn, dst);
case PNK_IMPORT:
return importDeclaration(pn, dst);
case PNK_NAME:
LOCAL_ASSERT(pn->isUsed());
return statement(pn->pn_lexdef, dst);

3
js/src/vm/CommonPropertyNames.h
Просмотреть файл

@ -15,7 +15,6 @@
macro(anonymous, anonymous, "anonymous") \
macro(apply, apply, "apply") \
macro(arguments, arguments, "arguments") \
macro(as, as, "as") \
macro(ArrayType, ArrayType, "ArrayType") \
macro(buffer, buffer, "buffer") \
macro(builder, builder, "builder") \
@ -44,7 +43,6 @@
macro(DateTimeFormatFormatGet, DateTimeFormatFormatGet, "Intl_DateTimeFormat_format_get") \
macro(decodeURI, decodeURI, "decodeURI") \
macro(decodeURIComponent, decodeURIComponent, "decodeURIComponent") \
macro(default_, default_, "default") \
macro(defineProperty, defineProperty, "defineProperty") \
macro(defineGetter, defineGetter, "__defineGetter__") \
macro(defineSetter, defineSetter, "__defineSetter__") \
@ -70,7 +68,6 @@
macro(float32, float32, "float32") \
macro(float64, float64, "float64") \
macro(format, format, "format") \
macro(from, from, "from") \
macro(get, get, "get") \
macro(getInternals, getInternals, "getInternals") \
macro(getOwnPropertyDescriptor, getOwnPropertyDescriptor, "getOwnPropertyDescriptor") \

2
js/src/vm/Keywords.h
Просмотреть файл

@ -41,12 +41,12 @@
macro(void, void_, TOK_VOID, JSVERSION_DEFAULT) \
macro(while, while_, TOK_WHILE, JSVERSION_DEFAULT) \
macro(with, with, TOK_WITH, JSVERSION_DEFAULT) \
macro(import, import, TOK_IMPORT, JSVERSION_DEFAULT) \
/* Reserved keywords. */ \
macro(class, class_, TOK_RESERVED, JSVERSION_DEFAULT) \
macro(enum, enum_, TOK_RESERVED, JSVERSION_DEFAULT) \
macro(export, export, TOK_RESERVED, JSVERSION_DEFAULT) \
macro(extends, extends, TOK_RESERVED, JSVERSION_DEFAULT) \
macro(import, import, TOK_RESERVED, JSVERSION_DEFAULT) \
macro(super, super, TOK_RESERVED, JSVERSION_DEFAULT) \
/* Future reserved keywords, but only in strict mode. */ \
macro(implements, implements, TOK_STRICT_RESERVED, JSVERSION_DEFAULT) \