Fix support for multiple "block lambda" arguments.

[cycript.git] / Replace.cpp

diff --git a/Replace.cpp b/Replace.cpp
index bcaffca8cd39ad9e3376c3ff0c43a3907ea55e7c..2ac69422c4904914191a99c809d1f1d600f8596d 100644 (file)
--- a/Replace.cpp
+++ b/Replace.cpp
@@ -19,16 +19,21 @@
 **/
 /* }}} */
 
-#include "Parser.hpp"
-#include "Replace.hpp"
-
 #include <iomanip>
 
+#include "Replace.hpp"
+#include "Syntax.hpp"
+
 CYFunctionExpression *CYNonLocalize(CYContext &context, CYFunctionExpression *function) {
     function->nonlocal_ = context.nextlocal_;
     return function;
 }
 
+static void CYImplicitReturn(CYStatement *&code) {
+    if (CYStatement *&last = CYGetLast(code))
+        last = last->Return();
+}
+
 CYExpression *CYAdd::Replace(CYContext &context) {
     CYInfix::Replace(context);
 
@@ -75,7 +80,8 @@ CYArgument *CYArgument::Replace(CYContext &context) { $T(NULL)
 }
 
 CYExpression *CYArray::Replace(CYContext &context) {
-    elements_->Replace(context);
+    if (elements_ != NULL)
+        elements_->Replace(context);
     return this;
 }
 
@@ -95,9 +101,14 @@ CYExpression *CYAssignment::Replace(CYContext &context) {
     return this;
 }
 
+CYStatement *CYBlock::Return() {
+    CYImplicitReturn(code_);
+    return this;
+}
+
 CYStatement *CYBlock::Replace(CYContext &context) {
-    context.ReplaceAll(statements_);
-    if (statements_ == NULL)
+    context.ReplaceAll(code_);
+    if (code_ == NULL)
         return $ CYEmpty();
     return this;
 }
@@ -124,31 +135,24 @@ namespace cy {
 namespace Syntax {
 
 void Catch::Replace(CYContext &context) { $T()
-    CYScope scope(true, context, code_.statements_);
+    CYScope scope(true, context);
 
     context.Replace(name_);
     context.scope_->Declare(context, name_, CYIdentifierCatch);
 
-    code_.Replace(context);
-    scope.Close();
+    context.ReplaceAll(code_);
+    scope.Close(context, code_);
 }
 
 } }
 
 void CYClause::Replace(CYContext &context) { $T()
     context.Replace(case_);
-    context.ReplaceAll(statements_);
+    context.ReplaceAll(code_);
     next_->Replace(context);
 }
 
-CYStatement *CYComment::Replace(CYContext &context) {
-    return this;
-}
-
 CYExpression *CYCompound::Replace(CYContext &context) {
-    if (next_ == NULL)
-        return expression_;
-
     context.Replace(expression_);
     context.Replace(next_);
 
@@ -162,22 +166,10 @@ CYExpression *CYCompound::Replace(CYContext &context) {
     return this;
 }
 
-CYExpression *CYCompound::Primitive(CYContext &context) {
-    CYExpression *expression(expression_);
-    if (expression == NULL || next_ != NULL)
+CYFunctionParameter *CYCompound::Parameter() const {
+    CYFunctionParameter *next(next_->Parameter());
+    if (next == NULL)
         return NULL;
-    return expression->Primitive(context);
-}
-
-CYFunctionParameter *CYCompound::Parameters() const {
-    CYFunctionParameter *next;
-    if (next_ == NULL)
-        next = NULL;
-    else {
-        next = next_->Parameters();
-        if (next == NULL)
-            return NULL;
-    }
 
     CYFunctionParameter *parameter(expression_->Parameter());
     if (parameter == NULL)
@@ -223,6 +215,7 @@ void CYContext::NonLocal(CYStatement *&statements) {
                     $ CYReturn($M($V(cye), $S("$cyv"))))->*
                 $ cy::Syntax::Throw($V(cye))));
 
+        // XXX: I don't understand any of this
         context.Replace(declare);
         rescue->Replace(context);
 
@@ -284,10 +277,13 @@ CYArgument *CYDeclarations::Argument(CYContext &context) { $T(NULL)
     return $ CYArgument(declaration_->initialiser_, next_->Argument(context));
 }
 
-CYCompound *CYDeclarations::Compound(CYContext &context) { $T(NULL)
-    CYCompound *compound(next_->Compound(context));
+CYExpression *CYDeclarations::Expression(CYContext &context) { $T(NULL)
+    CYExpression *compound(next_->Expression(context));
     if (CYAssignment *assignment = declaration_->Assignment(context))
-        compound = $ CYCompound(assignment, compound);
+        if (compound == NULL)
+            compound = assignment;
+        else
+            compound = $ CYCompound(assignment, compound);
     return compound;
 }
 
@@ -299,13 +295,18 @@ CYExpression *CYDirectMember::Replace(CYContext &context) {
 
 CYStatement *CYDoWhile::Replace(CYContext &context) {
     context.Replace(test_);
-    context.Replace(code_);
+    context.ReplaceAll(code_);
     return this;
 }
 
-void CYElement::Replace(CYContext &context) { $T()
+void CYElementSpread::Replace(CYContext &context) {
     context.Replace(value_);
-    next_->Replace(context);
+}
+
+void CYElementValue::Replace(CYContext &context) {
+    context.Replace(value_);
+    if (next_ != NULL)
+        next_->Replace(context);
 }
 
 CYStatement *CYEmpty::Replace(CYContext &context) {
@@ -316,16 +317,12 @@ CYExpression *CYEncodedType::Replace(CYContext &context) {
     return typed_->Replace(context);
 }
 
-CYStatement *CYExpress::Replace(CYContext &context) {
-    while (CYExpress *express = dynamic_cast<CYExpress *>(next_)) {
-        expression_ = $ CYCompound(expression_, express->expression_);
-        SetNext(express->next_);
-    }
+CYStatement *CYExpress::Return() {
+    return $ CYReturn(expression_);
+}
 
+CYStatement *CYExpress::Replace(CYContext &context) {
     context.Replace(expression_);
-    if (expression_ == NULL)
-        return $ CYEmpty();
-
     return this;
 }
 
@@ -349,10 +346,6 @@ CYFunctionParameter *CYExpression::Parameter() const {
     return NULL;
 }
 
-CYFunctionParameter *CYExpression::Parameters() const {
-    return NULL;
-}
-
 CYStatement *CYExternal::Replace(CYContext &context) {
     return $E($ CYAssign($V(typed_->identifier_), $C1(typed_->Replace(context), $C2($V("dlsym"), $V("RTLD_DEFAULT"), $S(typed_->identifier_->Word())))));
 }
@@ -372,20 +365,20 @@ CYExpression *CYFatArrow::Replace(CYContext &context) {
 }
 
 void CYFinally::Replace(CYContext &context) { $T()
-    code_.Replace(context);
+    context.ReplaceAll(code_);
 }
 
 CYStatement *CYFor::Replace(CYContext &context) {
     context.Replace(initialiser_);
     context.Replace(test_);
     context.Replace(increment_);
-    context.Replace(code_);
+    context.ReplaceAll(code_);
     return this;
 }
 
-CYCompound *CYForDeclarations::Replace(CYContext &context) {
+CYExpression *CYForDeclarations::Replace(CYContext &context) {
     declarations_->Replace(context);
-    return declarations_->Compound(context);
+    return declarations_->Expression(context);
 }
 
 // XXX: this still feels highly suboptimal
@@ -398,16 +391,16 @@ CYStatement *CYForIn::Replace(CYContext &context) {
 
     context.Replace(initialiser_);
     context.Replace(set_);
-    context.Replace(code_);
+    context.ReplaceAll(code_);
     return this;
 }
 
 CYFunctionParameter *CYForInComprehension::Parameter(CYContext &context) const {
-    return $ CYFunctionParameter($ CYDeclaration(name_));
+    return $ CYFunctionParameter(declaration_);
 }
 
 CYStatement *CYForInComprehension::Replace(CYContext &context, CYStatement *statement) const {
-    return $ CYForIn($V(name_), set_, CYComprehension::Replace(context, statement));
+    return $ CYForIn(declaration_->Variable(context), set_, CYComprehension::Replace(context, statement));
 }
 
 CYStatement *CYForOf::Replace(CYContext &context) {
@@ -428,7 +421,7 @@ CYStatement *CYForOf::Replace(CYContext &context) {
 }
 
 CYFunctionParameter *CYForOfComprehension::Parameter(CYContext &context) const {
-    return $ CYFunctionParameter($ CYDeclaration(name_));
+    return $ CYFunctionParameter(declaration_);
 }
 
 CYStatement *CYForOfComprehension::Replace(CYContext &context, CYStatement *statement) const {
@@ -436,8 +429,8 @@ CYStatement *CYForOfComprehension::Replace(CYContext &context, CYStatement *stat
 
     return $E($C0($F(NULL, $P1($L("$cys")), $$->*
         $E($ CYAssign($V(cys), set_))->*
-        $ CYForIn($V(name_), $V(cys), $ CYBlock($$->*
-            $E($ CYAssign($V(name_), $M($V(cys), $V(name_))))->*
+        $ CYForIn(declaration_->Variable(context), $V(cys), $ CYBlock($$->*
+            $E($ CYAssign(declaration_->Variable(context), $M($V(cys), declaration_->Variable(context))))->*
             CYComprehension::Replace(context, statement)
         ))
     )));
@@ -453,7 +446,8 @@ void CYFunction::Replace_(CYContext &context, bool outer) {
         Inject(context);
 
     CYThisScope *_this(context.this_);
-    context.this_ = CYGetLast(&this_);
+    context.this_ = &this_;
+    context.this_ = CYGetLast(context.this_);
 
     CYNonLocal *nonlocal(context.nonlocal_);
     CYNonLocal *nextlocal(context.nextlocal_);
@@ -468,28 +462,31 @@ void CYFunction::Replace_(CYContext &context, bool outer) {
         context.nextlocal_ = nonlocal_;
     }
 
-    CYScope scope(!localize, context, code_.statements_);
+    CYScope scope(!localize, context);
 
     if (!outer && name_ != NULL)
         Inject(context);
 
     parameters_->Replace(context, code_);
-    code_.Replace(context);
+    context.ReplaceAll(code_);
+
+    if (implicit_)
+        CYImplicitReturn(code_);
 
     if (CYIdentifier *identifier = this_.identifier_)
-        code_.statements_ = $$->*
+        code_ = $$->*
             $ CYVar($L1($ CYDeclaration(identifier, $ CYThis())))->*
-            code_.statements_;
+            code_;
 
     if (localize)
-        context.NonLocal(code_.statements_);
+        context.NonLocal(code_);
 
     context.nextlocal_ = nextlocal;
     context.nonlocal_ = nonlocal;
 
     context.this_ = _this;
 
-    scope.Close();
+    scope.Close(context, code_);
 }
 
 CYExpression *CYFunctionExpression::Replace(CYContext &context) {
@@ -497,17 +494,19 @@ CYExpression *CYFunctionExpression::Replace(CYContext &context) {
     return this;
 }
 
-void CYFunctionParameter::Replace(CYContext &context, CYBlock &code) { $T()
+void CYFunctionParameter::Replace(CYContext &context, CYStatement *&statements) { $T()
     CYAssignment *assignment(initialiser_->Assignment(context));
     context.Replace(initialiser_);
 
-    next_->Replace(context, code);
+    next_->Replace(context, statements);
 
     if (assignment != NULL)
-        // XXX: this cast is quite incorrect
-        code.AddPrev($ CYIf($ CYIdentical($ CYTypeOf(dynamic_cast<CYExpression *>(initialiser_)), $S("undefined")), $$->*
-            $E(assignment)
-        ));
+        statements = $$->*
+            // XXX: this cast is quite incorrect
+            $ CYIf($ CYIdentical($ CYTypeOf(dynamic_cast<CYExpression *>(initialiser_)), $S("undefined")), $$->*
+                $E(assignment)
+            )->*
+            statements;
 }
 
 CYStatement *CYFunctionStatement::Replace(CYContext &context) {
@@ -522,10 +521,16 @@ CYIdentifier *CYIdentifier::Replace(CYContext &context) {
     return replace_;
 }
 
+CYStatement *CYIf::Return() {
+    CYImplicitReturn(true_);
+    CYImplicitReturn(false_);
+    return this;
+}
+
 CYStatement *CYIf::Replace(CYContext &context) {
     context.Replace(test_);
-    context.Replace(true_);
-    context.Replace(false_);
+    context.ReplaceAll(true_);
+    context.ReplaceAll(false_);
     return this;
 }
 
@@ -561,7 +566,7 @@ CYStatement *CYLabel::Replace(CYContext &context) {
 }
 
 CYExpression *CYLambda::Replace(CYContext &context) {
-    return $N2($V("Functor"), $ CYFunctionExpression(NULL, parameters_->Parameters(context), statements_), parameters_->TypeSignature(context, typed_->Replace(context)));
+    return $N2($V("Functor"), $ CYFunctionExpression(NULL, parameters_->Parameters(context), code_), parameters_->TypeSignature(context, typed_->Replace(context)));
 }
 
 CYStatement *CYLetStatement::Replace(CYContext &context) {
@@ -622,6 +627,10 @@ CYExpression *CYObject::Replace(CYContext &context) {
     return this;
 }
 
+CYExpression *CYParenthetical::Replace(CYContext &context) {
+    return expression_;
+}
+
 CYExpression *CYPostfix::Replace(CYContext &context) {
     context.Replace(lhs_);
     return this;
@@ -650,14 +659,14 @@ namespace {
     typedef std::set<CYIdentifier *, IdentifierUsageLess> IdentifierUsages;
 }
 
-void CYProgram::Replace(CYContext &context) {
-    CYScope scope(true, context, statements_);
+void CYScript::Replace(CYContext &context) {
+    CYScope scope(true, context);
 
     context.nextlocal_ = $ CYNonLocal();
-    context.ReplaceAll(statements_);
-    context.NonLocal(statements_);
+    context.ReplaceAll(code_);
+    context.NonLocal(code_);
 
-    scope.Close();
+    scope.Close(context, code_);
 
     size_t offset(0);
 
@@ -726,29 +735,25 @@ CYStatement *CYReturn::Replace(CYContext &context) {
 }
 
 CYExpression *CYRubyBlock::Replace(CYContext &context) {
-    // XXX: this needs to do something much more epic to handle return
     return call_->AddArgument(context, proc_->Replace(context));
 }
 
+CYExpression *CYRubyBlock::AddArgument(CYContext &context, CYExpression *value) {
+    return Replace(context)->AddArgument(context, value);
+}
+
 CYExpression *CYRubyProc::Replace(CYContext &context) {
-    return CYNonLocalize(context, $ CYFunctionExpression(NULL, parameters_, code_));
+    CYFunctionExpression *function($ CYFunctionExpression(NULL, parameters_, code_));
+    function = CYNonLocalize(context, function);
+    function->implicit_ = true;
+    return function;
 }
 
-CYScope::CYScope(bool transparent, CYContext &context, CYStatement *&statements) :
+CYScope::CYScope(bool transparent, CYContext &context) :
     transparent_(transparent),
-    context_(context),
-    statements_(statements),
     parent_(context.scope_)
 {
-    context_.scope_ = this;
-}
-
-CYScope::~CYScope() {
-}
-
-void CYScope::Close() {
-    context_.scope_ = parent_;
-    Scope(context_, statements_);
+    context.scope_ = this;
 }
 
 void CYScope::Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags) {
@@ -806,7 +811,9 @@ namespace {
     typedef std::set<IdentifierOffset, IdentifierOffsetLess> IdentifierOffsets;
 }
 
-void CYScope::Scope(CYContext &context, CYStatement *&statements) {
+void CYScope::Close(CYContext &context, CYStatement *&statements) {
+    context.scope_ = parent_;
+
     if (parent_ == NULL)
         return;
 
@@ -856,6 +863,14 @@ void CYScope::Scope(CYContext &context, CYStatement *&statements) {
         }
 }
 
+CYElementValue *CYSpan::Replace(CYContext &context) { $T(NULL)
+    return $ CYElementValue(expression_, $ CYElementValue(string_, next_->Replace(context)));
+}
+
+CYStatement *CYStatement::Return() {
+    return this;
+}
+
 CYString *CYString::Concat(CYContext &context, CYString *rhs) const {
     size_t size(size_ + rhs->size_);
     char *value($ char[size + 1]);
@@ -880,6 +895,10 @@ CYStatement *CYSwitch::Replace(CYContext &context) {
     return this;
 }
 
+CYExpression *CYTemplate::Replace(CYContext &context) {
+    return $C2($M($M($M($V("String"), $S("prototype")), $S("concat")), $S("apply")), $S(""), $ CYArray($ CYElementValue(string_, spans_->Replace(context))));
+}
+
 CYExpression *CYThis::Replace(CYContext &context) {
     if (context.this_ != NULL)
         return $V(context.this_->Identifier(context));
@@ -912,7 +931,7 @@ namespace cy {
 namespace Syntax {
 
 CYStatement *Try::Replace(CYContext &context) {
-    code_.Replace(context);
+    context.ReplaceAll(code_);
     catch_->Replace(context);
     finally_->Replace(context);
     return this;
@@ -1012,8 +1031,8 @@ CYExpression *CYTypedParameter::TypeSignature(CYContext &context, CYExpression *
 
 CYStatement *CYVar::Replace(CYContext &context) {
     declarations_->Replace(context);
-    if (CYCompound *compound = declarations_->Compound(context))
-        return $E(compound);
+    if (CYExpression *expression = declarations_->Expression(context))
+        return $E(expression);
     return $ CYEmpty();
 }
 
@@ -1028,13 +1047,13 @@ CYFunctionParameter *CYVariable::Parameter() const {
 
 CYStatement *CYWhile::Replace(CYContext &context) {
     context.Replace(test_);
-    context.Replace(code_);
+    context.ReplaceAll(code_);
     return this;
 }
 
 CYStatement *CYWith::Replace(CYContext &context) {
     context.Replace(scope_);
-    context.Replace(code_);
+    context.ReplaceAll(code_);
     return this;
 }