From: Jay Freeman (saurik) <saurik@saurik.com>
Date: Mon, 21 Dec 2015 09:47:16 +0000 (-0800)
Subject: Transform ECMAScript 6 import as CommonJS require.
X-Git-Tag: v0.9.590~164
X-Git-Url: https://git.saurik.com/cycript.git/commitdiff_plain/90dd6ff11965499c5a211e2b78755baa3ab2e09c

Transform ECMAScript 6 import as CommonJS require.
---

diff --git a/Driver.hpp b/Driver.hpp
index dce9213..adb03f2 100644
--- a/Driver.hpp
+++ b/Driver.hpp
@@ -123,7 +123,7 @@ class _visible CYDriver {
     CYDriver(CYPool &pool, std::streambuf &data, const std::string &filename = "");
     ~CYDriver();
 
-    bool Parse(CYMark mark = CYMarkScript);
+    bool Parse(CYMark mark = CYMarkModule);
     void Replace(CYOptions &options);
 
     void SetRegEx(bool equal);
diff --git a/Execute.cpp b/Execute.cpp
index 3d9d6c4..c6812a2 100644
--- a/Execute.cpp
+++ b/Execute.cpp
@@ -2092,7 +2092,13 @@ static JSValueRef require(JSContextRef context, JSObjectRef object, JSObjectRef
         CYCallAsFunction(context, function, NULL, 3, arguments);
     }
 
-    return CYGetProperty(context, module, property);
+    JSObjectRef exports(CYCastJSObject(context, CYGetProperty(context, module, property)));
+
+    CYJSString _default("default");
+    if (JSValueIsUndefined(context, CYGetProperty(context, exports, _default)))
+        CYSetProperty(context, exports, _default, exports, kJSPropertyAttributeDontEnum);
+
+    return exports;
 } CYCatch(NULL) }
 
 static bool CYRunScript(JSGlobalContextRef context, const char *path) {
diff --git a/Output.cpp b/Output.cpp
index d3da0e4..5a2d759 100644
--- a/Output.cpp
+++ b/Output.cpp
@@ -520,6 +520,10 @@ void CYImport::Output(CYOutput &out, CYFlags flags) const {
     out << "@import";
 }
 
+void CYImportDeclaration::Output(CYOutput &out, CYFlags flags) const {
+    _assert(false);
+}
+
 void CYIndirect::Output(CYOutput &out, CYFlags flags) const {
     out << "*";
     rhs_->Output(out, Precedence(), CYRight(flags));
diff --git a/Parser.ypp.in b/Parser.ypp.in
index e1c2368..3d5aa6d 100644
--- a/Parser.ypp.in
+++ b/Parser.ypp.in
@@ -61,6 +61,7 @@
 %union { CYForInInitializer *forin_; }
 %union { CYFunctionParameter *functionParameter_; }
 %union { CYIdentifier *identifier_; }
+%union { CYImportSpecifier *import_; }
 %union { CYInfix *infix_; }
 %union { CYLiteral *literal_; }
 %union { CYMethod *method_; }
@@ -357,6 +358,7 @@ type; })
 %token _null_ "null"
 %token _true_ "true"
 
+%token _as_ "as"
 %token _break_ "break"
 %token _case_ "case"
 %token _catch_ "catch"
@@ -536,6 +538,7 @@ type; })
 %type <functionParameter_> FormalParameterList_
 %type <functionParameter_> FormalParameterList
 %type <functionParameter_> FormalParameters
+%type <string_> FromClause
 %type <statement_> FunctionBody
 %type <statement_> FunctionDeclaration
 %type <target_> FunctionExpression
@@ -553,6 +556,14 @@ type; })
 %type <word_> IdentifierName
 %type <variable_> IdentifierReference
 %type <statement_> IfStatement
+%type <import_> ImportClause
+%type <statement_> ImportDeclaration
+%type <import_> ImportSpecifier
+%type <identifier_> ImportedBinding
+%type <import_> ImportedDefaultBinding
+%type <import_> ImportsList_
+%type <import_> ImportsList
+%type <import_> ImportsListOpt
 %type <target_> IndirectExpression
 %type <expression_> Initializer
 %type <expression_> InitializerOpt
@@ -573,8 +584,16 @@ type; })
 %type <access_> MemberAccess
 %type <target_> MemberExpression
 %type <method_> MethodDefinition
+%type <statement_> ModuleBody
+%type <statement_> ModuleBodyOpt
+%type <statement_> ModuleItem
+%type <statement_> ModuleItemList
+%type <statement_> ModuleItemListOpt
 %type <module_> ModulePath
+%type <string_> ModuleSpecifier
 %type <expression_> MultiplicativeExpression
+%type <import_> NameSpaceImport
+%type <import_> NamedImports
 %type <target_> NewExpression
 %type <null_> NullLiteral
 %type <literal_> ObjectLiteral
@@ -910,6 +929,7 @@ LabelIdentifier
 IdentifierTypeNoOf
     : Identifier_[pass] { $$ = $pass; }
     | "abstract" { $$ = CYNew CYIdentifier("abstract"); }
+    | "as" { $$ = CYNew CYIdentifier("as"); }
     | "await" { $$ = CYNew CYIdentifier("await"); }
     | "boolean" { $$ = CYNew CYIdentifier("boolean"); }
     | "byte" { $$ = CYNew CYIdentifier("byte"); }
@@ -1828,88 +1848,88 @@ ScriptBodyOpt
 /* }}} */
 /* 15.2 Modules {{{ */
 Module
-    : ModuleBodyOpt
+    : ModuleBodyOpt[code] { driver.script_ = CYNew CYScript($code); }
     ;
 
 ModuleBody
-    : ModuleItemList
+    : ModuleItemList[pass] { $$ = $pass; }
     ;
 
 ModuleBodyOpt
-    : ModuleBody
-    |
+    : ModuleBody[pass] { $$ = $pass; }
+    | LexSetStatement LexLet LexOf { $$ = NULL; }
     ;
 
 ModuleItemList
-    : ModuleItemListOpt ModuleItem
+    : ModuleItem[statement] ModuleItemListOpt[next] { $$ = $statement; CYSetLast($$) = $next; }
     ;
 
 ModuleItemListOpt
-    : ModuleItemList
-    |
+    : ModuleItemList[pass] { $$ = $pass; }
+    | LexSetStatement LexLet LexOf { $$ = NULL; }
     ;
 
 ModuleItem
-    : LexSetStatement LexLet LexOf ImportDeclaration
-    | LexSetStatement LexLet LexOf ExportDeclaration
-    | StatementListItem
+    : LexSetStatement LexLet LexOf ImportDeclaration[pass] { $$ = $pass; }
+    | LexSetStatement LexLet LexOf ExportDeclaration { CYNOT(@$); }
+    | StatementListItem[pass] { $$ = $pass; }
     ;
 /* }}} */
 /* 15.2.2 Imports {{{ */
 ImportDeclaration
-    : "import" ImportClause FromClause Terminator
-    | "import" LexOf ModuleSpecifier Terminator
+    : "import" ImportClause[specifiers] FromClause[module] Terminator { $$ = CYNew CYImportDeclaration($specifiers, $module); }
+    | "import" LexOf ModuleSpecifier[module] Terminator { $$ = CYNew CYImportDeclaration(NULL, $module); }
     ;
 
 ImportClause
-    : ImportedDefaultBinding
-    | LexOf NameSpaceImport
-    | LexOf NamedImports
-    | ImportedDefaultBinding "," NameSpaceImport
-    | ImportedDefaultBinding "," NamedImports
+    : ImportedDefaultBinding[default] { $$ = $default; }
+    | LexOf NameSpaceImport[pass] { $$ = $pass; }
+    | LexOf NamedImports[pass] { $$ = $pass; }
+    | ImportedDefaultBinding[default] "," NameSpaceImport[next] { $$ = $default; CYSetLast($$) = $next; }
+    | ImportedDefaultBinding[default] "," NamedImports[next] { $$ = $default; CYSetLast($$) = $next; }
     ;
 
 ImportedDefaultBinding
-    : ImportedBinding
+    : ImportedBinding[binding] { $$ = CYNew CYImportSpecifier(CYNew CYIdentifier("default"), $binding); }
     ;
 
 NameSpaceImport
-    : "*" "as" ImportedBinding
+    : "*" "as" ImportedBinding[binding] { $$ = CYNew CYImportSpecifier(NULL, $binding); }
     ;
 
 NamedImports
-    : "{" ImportsListOpt "}"
+    : "{" ImportsListOpt[pass] "}" { $$ = $pass; }
     ;
 
 FromClause
-    : "from" ModuleSpecifier
+    : "from" ModuleSpecifier[pass] { $$ = $pass; }
     ;
 
 ImportsList_
-    : "," ImportsListOpt
-    |
+    : "," ImportsListOpt[pass] { $$ = $pass; }
+    | { $$ = NULL; }
     ;
 
 ImportsList
-    : ImportSpecifier ImportsList_
+    : ImportSpecifier[import] ImportsList_[next] { $$ = $import; CYSetLast($$) = $next; }
     ;
 
 ImportsListOpt
-    : ImportsList
-    | LexOf
+    : ImportsList[pass] { $$ = $pass; }
+    | LexOf { $$ = NULL; }
     ;
 
 ImportSpecifier
-    : ImportedBinding
-    | LexOf IdentifierName "as" ImportedBinding
+    : ImportedBinding[binding] { $$ = CYNew CYImportSpecifier($binding, $binding); }
+    | LexOf IdentifierName[name] "as" ImportedBinding[binding] { $$ = CYNew CYImportSpecifier($name, $binding); }
     ;
 
 ModuleSpecifier
-    : StringLiteral
+    : StringLiteral[pass] { $$ = $pass; }
     ;
 
 ImportedBinding
-    : BindingIdentifier
+    : BindingIdentifier[pass] { $$ = $pass; }
     ;
 /* }}} */
 /* 15.2.3 Exports {{{ */
diff --git a/Replace.cpp b/Replace.cpp
index 307ccec..7f5ca53 100644
--- a/Replace.cpp
+++ b/Replace.cpp
@@ -623,6 +623,27 @@ CYStatement *CYImport::Replace(CYContext &context) {
     return $ CYVar($B1($B($I(module_->part_->Word()), $C1($V("require"), module_->Replace(context, "/")))));
 }
 
+CYStatement *CYImportDeclaration::Replace(CYContext &context) {
+    CYIdentifier *module(context.Unique());
+
+    CYList<CYStatement> statements;
+    CYForEach (specifier, specifiers_)
+        statements->*specifier->Replace(context, module);
+
+    return $ CYBlock($$
+        ->* $ CYLexical(false, $B1($B(module, $C1($V("require"), module_))))
+        ->* statements);
+}
+
+CYStatement *CYImportSpecifier::Replace(CYContext &context, CYIdentifier *module) {
+    binding_ = binding_->Replace(context, CYIdentifierLexical);
+
+    CYExpression *import($V(module));
+    if (name_ != NULL)
+        import = $M(import, $S(name_));
+    return $E($ CYAssign($V(binding_), import));
+}
+
 CYTarget *CYIndirect::Replace(CYContext &context) {
     return $M(rhs_, $S("$cyi"));
 }
diff --git a/Scanner.lpp.in b/Scanner.lpp.in
index 235dc80..bb533e0 100644
--- a/Scanner.lpp.in
+++ b/Scanner.lpp.in
@@ -444,6 +444,7 @@ XMLName {XMLNameStart}{XMLNamePart}*
     /* }}} */
     /* Reserved {{{ */
 "abstract"        L /*FII*/ F(tk::_abstract_, hi::Meta);
+"as"              L /*III*/ F(tk::_as_, hi::Meta);
 "await"           L /*II?*/ F(tk::_await_, hi::Meta);
 "boolean"         L /*FII*/ F(tk::_boolean_, hi::Type);
 "break"           L /*KKK*/ F(tk::_break_, hi::Control);
diff --git a/Syntax.hpp b/Syntax.hpp
index cb39f40..bc16084 100644
--- a/Syntax.hpp
+++ b/Syntax.hpp
@@ -2238,6 +2238,39 @@ struct CYImport :
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
+struct CYImportSpecifier :
+    CYNext<CYImportSpecifier>
+{
+    CYWord *name_;
+    CYIdentifier *binding_;
+
+    CYImportSpecifier(CYWord *name, CYIdentifier *binding) :
+        name_(name),
+        binding_(binding)
+    {
+    }
+
+    CYStatement *Replace(CYContext &context, CYIdentifier *module);
+};
+
+struct CYImportDeclaration :
+    CYStatement
+{
+    CYImportSpecifier *specifiers_;
+    CYString *module_;
+
+    CYImportDeclaration(CYImportSpecifier *specifiers, CYString *module) :
+        specifiers_(specifiers),
+        module_(module)
+    {
+    }
+
+    CYCompact(None)
+
+    virtual CYStatement *Replace(CYContext &context);
+    virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
 struct CYExternal :
     CYStatement
 {