spec.html

<pre class=metadata>
title: Syntactic Tail Calls
contributors: Brian Terlson, Eric Faust
</pre>
<link rel="stylesheet" href="ecmarkup.css">
<script src="ecmarkup.js"></script>
<emu-intro>
This document introduces explicit syntax for tail calls. For motivation and an introduction, see
<a href="https://github.com/tc39/proposal-ptc-syntax/blob/master/README.md">the explainer document</a>.
The specification here defines the grammar for explicit tail calls and the runtime semantics which
guarantee tail call elimination for explicit tail call sites and removes guaranteed tail call
elimination from the cases where it was implicitly supported in ES2015. This specification still
<em>permits</em> tail call elimination in other cases, but does not <em>require</em> it.
  <emu-intro id="TailCallExpression-grammar-examples">
    <h1>Examples</h1>

    <p>The following examples are all syntactically valid: </p>
    <pre><code class=javascript>
      function foo1() { return continue bar(); }
      function foo2() { return continue bar`template`; }
      function foo3() { return bool ? continue bar() : baz }

      let foo4 = () =&gt; continue foo();
      let foo5 = () =&gt; bool ? continue bar() : baz;
    </pre></code>

    <p>The following examples are all syntax errors: </p>
    <pre><code class=javascript>
      continue bar();
      // continue in a statement context is still a ContinueStatement.

      (continue bar());
      // continue is only syntactically valid under a return statement

      function foo1() { return continue baz; }
      function foo2() { return continue 1 + baz() }
      function foo3() { return continue baz(), 1 }
      // things that aren't tail calls are syntax errors
    </pre></code>
  </emu-intro>
</emu-intro>
<emu-clause id="TailCallExpression">
  <h1>Tail Calls</h1>
  <h2>Syntax</h2>
  <emu-grammar>
    AssignmentExpression[In, Yield] :
      ConditionalExpression[?In, ?Yield]
      [+Yield] YieldExpression[?In]
      ArrowFunction[?In, ?Yield]
      LeftHandSideExpression[?Yield] `=` AssignmentExpression[?In, ?Yield]
      LeftHandSideExpression[?Yield] AssignmentOperator AssignmentExpression[?In, ?Yield]
      <ins>TailCallExpression[?Yield]</ins>

    TailCallExpression[Yield] :
      `continue` MemberExpression[?Yield] Arguments[?Yield]
      `continue` CallExpression[?Yield] Arguments[?Yield]
      `continue` MemberExpression[?Yield] TemplateLiteral[?Yield]
      `continue` CallExpression[?Yield] TemplateLiteral[?Yield]
  </emu-grammar>

  <emu-clause id="TailCallExpression-early-errors">
    <h1>Static Semantics: Early Errors</h1>
    <ul>
      <li>It is a Syntax Error IsInTailPosition of |TailCallExpression| is *false*.</li>
      <li>It is a Syntax Error if the StringValue of the |MemberExpression| is `eval`.</li>
    </ul>
  </emu-clause>

  <emu-clause id="TailCallExpression-evaluation">
    <h1>Runtime Semantics: Evaluation</h1>
        <emu-grammar>TailCallExpression : `continue` MemberExpression Arguments</emu-grammar>
        <emu-alg>
          1. Let _ref_ be the result of evaluating |MemberExpression|.
          1. Let _func_ be ? GetValue(_ref_).
          1. If Type(_ref_) is Reference, then
            1. If IsPropertyReference(_ref_) is *true*, then
              1. Let _thisValue_ be GetThisValue(_ref_).
            1. Else, the base of _ref_ is an Environment Record
              1. Let _refEnv_ be GetBase(_ref_).
              1. Let _thisValue_ be _refEnv_.WithBaseObject().
          1. Else Type(_ref_) is not Reference,
            1. Let _thisValue_ be *undefined*.
          1. Return ? EvaluateDirectCall(_func_, _thisValue_, |Arguments|, *true*).
        </emu-alg>
        <emu-grammar>TailCallExpression : `continue` CallExpression Arguments</emu-grammar>
        <emu-alg>
          1. Let _ref_ be the result of evaluating |CallExpression|.
          1. Return ? EvaluateCall(_ref_, |Arguments|, *true*).
        </emu-alg>
      </emu-clause>
      <emu-grammar>TailCallExpression : `continue` MemberExpression TemplateLiteral</emu-grammar>
      <emu-alg>
        1. Let _tagRef_ be the result of evaluating |MemberExpression|.
        1. Return ? EvaluateCall(_tagRef_, |TemplateLiteral|, *true*).
      </emu-alg>
      <emu-grammar>TailCallExpression : `continue` CallExpression TemplateLiteral</emu-grammar>
      <emu-alg>
        1. Let _tagRef_ be the result of evaluating |CallExpression|.
        1. Return ? EvaluateCall(_tagRef_, |TemplateLiteral|,  *true*).
    </emu-clause>
  </emu-clause>
</emu-clause>

<emu-clause id="patches">
  <h1>Modifications to existing algorithms</h1>
    <emu-clause id="sec-function-calls">
      <h1>Function Calls</h1>

      <!-- es6num="12.3.4.1" -->
      <emu-clause id="sec-function-calls-runtime-semantics-evaluation">
        <h1>Runtime Semantics: Evaluation</h1>
        <emu-grammar>CallExpression : MemberExpression Arguments</emu-grammar>
        <emu-alg>
          1. Let _ref_ be the result of evaluating |MemberExpression|.
          1. Let _func_ be ? GetValue(_ref_).
          1. If Type(_ref_) is Reference and IsPropertyReference(_ref_) is *false* and GetReferencedName(_ref_) is `"eval"`, then
            1. If SameValue(_func_, %eval%) is *true*, then
              1. Let _argList_ be ? ArgumentListEvaluation(|Arguments|).
              1. If _argList_ has no elements, return *undefined*.
              1. Let _evalText_ be the first element of _argList_.
              1. If the source code matching this |CallExpression| is strict code, let _strictCaller_ be *true*. Otherwise let _strictCaller_ be *false*.
              1. Let _evalRealm_ be the current Realm Record.
              1. Perform ? HostEnsureCanCompileStrings(_evalRealm_, _evalRealm_).
              1. Return ? PerformEval(_evalText_, _evalRealm_, _strictCaller_, *true*).
          1. If Type(_ref_) is Reference, then
            1. If IsPropertyReference(_ref_) is *true*, then
              1. Let _thisValue_ be GetThisValue(_ref_).
            1. Else, the base of _ref_ is an Environment Record
              1. Let _refEnv_ be GetBase(_ref_).
              1. Let _thisValue_ be _refEnv_.WithBaseObject().
          1. Else Type(_ref_) is not Reference,
            1. Let _thisValue_ be *undefined*.
          1. <del>Let _thisCall_ be this |CallExpression|.</del>
          1. <del>Let _tailCall_ be IsInTailPosition(_thisCall_).</del>
          1. Return ? EvaluateDirectCall(_func_, _thisValue_, |Arguments|, <del>_tailCall_</del><ins>*false*</ins>).
        </emu-alg>
        <p>A |CallExpression| evaluation that executes step 3.a.vi is a <dfn>direct eval</dfn>.</p>
        <emu-grammar>CallExpression : CallExpression Arguments</emu-grammar>
        <emu-alg>
          1. Let _ref_ be the result of evaluating |CallExpression|.
          1. <del>Let _thisCall_ be this |CallExpression|.</del>
          1. <del>Let _tailCall_ be IsInTailPosition(_thisCall_).</del>
          1. Return ? EvaluateCall(_ref_, |Arguments|, <del>_tailCall_</del><ins>*false*</ins>).
        </emu-alg>
      </emu-clause>
    </emu-clause>
    <emu-clause id="sec-tagged-templates">
      <h1>Tagged Templates</h1>
      <!-- es6num="12.3.7.1" -->
      <emu-clause id="sec-tagged-templates-runtime-semantics-evaluation">
        <h1>Runtime Semantics: Evaluation</h1>
        <emu-grammar>MemberExpression : MemberExpression TemplateLiteral</emu-grammar>
        <emu-alg>
          1. Let _tagRef_ be the result of evaluating |MemberExpression|.
          1. <del>Let _thisCall_ be this |CallExpression|.</del>
          1. <del>Let _tailCall_ be IsInTailPosition(_thisCall_).</del>
          1. Return ? EvaluateCall(_tagRef_, |TemplateLiteral|, <del>_tailCall_</del><ins>*false*</ins>).
        </emu-alg>
        <emu-grammar>CallExpression : CallExpression TemplateLiteral</emu-grammar>
        <emu-alg>
          1. Let _tagRef_ be the result of evaluating |CallExpression|.
          1. <del>Let _thisCall_ be this |CallExpression|.</del>
          1. <del>Let _tailCall_ be IsInTailPosition(_thisCall_).</del>
          1. Return ? EvaluateCall(_tagRef_, |TemplateLiteral|,  <del>_tailCall_</del><ins>*false*</ins>).
        </emu-alg>
      </emu-clause>
    </emu-clause>
    <emu-clause id="sec-static-semantics-hasproductionintailposition">
      <h1>Static Semantics: HasProductionInTailPosition</h1>
      <p>With parameter _nonterminal_.</p>
      <!-- es6num="14.6.2.2" -->
      <emu-clause id="sec-expression-rules">
        <h1>Expression Rules</h1>
        <emu-note>
          <p>A potential tail position call that is immediately followed by return GetValue of the call result is also a possible tail position call. Function calls cannot return reference values, so such a GetValue operation will always returns the same value as the actual function call result.</p>
        </emu-note>
        <emu-grammar>
          AssignmentExpression :
            YieldExpression
            ArrowFunction
            LeftHandSideExpression `=` AssignmentExpression
            LeftHandSideExpression AssignmentOperator AssignmentExpression

          BitwiseANDExpression : BitwiseANDExpression `&amp;` EqualityExpression

          BitwiseXORExpression : BitwiseXORExpression `^` BitwiseANDExpression

          BitwiseORExpression : BitwiseORExpression `|` BitwiseXORExpression

          EqualityExpression :
            EqualityExpression `==` RelationalExpression
            EqualityExpression `!=` RelationalExpression
            EqualityExpression `===` RelationalExpression
            EqualityExpression `!==` RelationalExpression

          RelationalExpression :
            RelationalExpression `&lt;` ShiftExpression
            RelationalExpression `&gt;` ShiftExpression
            RelationalExpression `&lt;=` ShiftExpression
            RelationalExpression `&gt;=` ShiftExpression
            RelationalExpression `instanceof` ShiftExpression
            RelationalExpression `in` ShiftExpression

          ShiftExpression :
            ShiftExpression `&lt;&lt;` AdditiveExpression
            ShiftExpression `&gt;&gt;` AdditiveExpression
            ShiftExpression `&gt;&gt;&gt;` AdditiveExpression

          AdditiveExpression :
            AdditiveExpression `+` MultiplicativeExpression
            AdditiveExpression `-` MultiplicativeExpression

          MultiplicativeExpression :
            MultiplicativeExpression MultiplicativeOperator ExponentiationExpression

          ExponentiationExpression :
            UpdateExpression `**` ExponentiationExpression

          UpdateExpression :
            LeftHandSideExpression `++`
            LeftHandSideExpression `--`
            `++` UnaryExpression
            `--` UnaryExpression

          UnaryExpression :
            `delete` UnaryExpression
            `void` UnaryExpression
            `typeof` UnaryExpression
            `+` UnaryExpression
            `-` UnaryExpression
            `~` UnaryExpression
            `!` UnaryExpression

          CallExpression :
            SuperCall
            CallExpression `[` Expression `]`
            CallExpression `.` IdentifierName

          NewExpression : `new` NewExpression

          MemberExpression :
            MemberExpression `[` Expression `]`
            MemberExpression `.` IdentifierName
            SuperProperty
            MetaProperty
            `new` MemberExpression Arguments

          PrimaryExpression :
            `this`
            IdentifierReference
            Literal
            ArrayLiteral
            ObjectLiteral
            FunctionExpression
            ClassExpression
            GeneratorExpression
            RegularExpressionLiteral
            TemplateLiteral
        </emu-grammar>
        <emu-alg>
          1. Return *false*.
        </emu-alg>
        <emu-grammar>
          Expression :
            AssignmentExpression
            Expression `,` AssignmentExpression
        </emu-grammar>
        <emu-alg>
          1. Return HasProductionInTailPosition of |AssignmentExpression| with argument _nonterminal_.
        </emu-alg>
        <emu-grammar>ConditionalExpression : LogicalORExpression `?` AssignmentExpression `:` AssignmentExpression</emu-grammar>
        <emu-alg>
          1. Let _has_ be HasProductionInTailPosition of the first |AssignmentExpression| with argument _nonterminal_.
          1. If _has_ is *true*, return *true*.
          1. Return HasProductionInTailPosition of the second |AssignmentExpression| with argument _nonterminal_.
        </emu-alg>
        <emu-grammar>LogicalANDExpression : LogicalANDExpression `&amp;&amp;` BitwiseORExpression</emu-grammar>
        <emu-alg>
          1. Return HasProductionInTailPosition of |BitwiseORExpression| with argument _nonterminal_.
        </emu-alg>
        <emu-grammar>LogicalORExpression : LogicalORExpression `||` LogicalANDExpression</emu-grammar>
        <emu-alg>
          1. Return HasProductionInTailPosition of |LogicalANDExpression| with argument _nonterminal_.
        </emu-alg>
        <emu-grammar>
          CallExpression :
            MemberExpression Arguments
            CallExpression Arguments
            CallExpression TemplateLiteral
        </emu-grammar>
        <emu-alg>
          1. <del>If this |CallExpression| is _nonterminal_, return *true*.</del>
          1. Return *false*.
        </emu-alg>
        <emu-grammar>
          MemberExpression :
            MemberExpression TemplateLiteral
        </emu-grammar>
        <emu-alg>
          1. <del>If this |MemberExpression| is _nonterminal_, return *true*.</del>
          1. Return *false*.
        </emu-alg>
        <emu-grammar>PrimaryExpression : CoverParenthesizedExpressionAndArrowParameterList</emu-grammar>
        <emu-alg>
          1. Let _expr_ be CoveredParenthesizedExpression of |CoverParenthesizedExpressionAndArrowParameterList|.
          1. Return HasProductionInTailPosition of _expr_ with argument _nonterminal_.
        </emu-alg>
        <emu-grammar>
          ParenthesizedExpression :
            `(` Expression `)`
        </emu-grammar>
        <emu-alg>
          1. Return HasProductionInTailPosition of |Expression| with argument _nonterminal_.
        </emu-alg>
        <emu-grammar>
          TailCallExpression[Yield] :
            `continue` MemberExpression[?Yield] Arguments[?Yield]
            `continue` CallExpression[?Yield] Arguments[?Yield]
            `continue` MemberExpression[?Yield] TemplateLiteral[?Yield]
            `continue` CallExpression[?Yield] TemplateLiteral[?Yield]
        </emu-grammar>
        <emu-alg>
          1. <ins>If this |TailCallExpression| is _nonterminal_, return *true*.</ins>
          1. <ins>Return *false*.</ins>
        </emu-alg>
      </emu-clause>
    </emu-clause>
</emu-clause>