mirror of
https://github.com/jashkenas/coffeescript.git
synced 2026-05-03 03:00:14 -04:00
Fixes #2783 -- leftover comments
This commit is contained in:
Jeremy Ashkenas
@@ -741,16 +741,8 @@ constructor.</p> </td> <td class="code"> <
|
||||
<span class="nv">body = </span><span class="k">new</span> <span class="nx">Block</span> <span class="p">[</span><span class="k">new</span> <span class="nx">Return</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s">"</span><span class="si">#{</span><span class="nx">@ctor</span><span class="p">.</span><span class="nx">name</span><span class="si">}</span><span class="s">.prototype.</span><span class="si">#{</span><span class="nx">name</span><span class="p">.</span><span class="nx">value</span><span class="si">}</span><span class="s">.apply(_this, arguments)"</span><span class="p">]</span>
|
||||
<span class="nv">rhs = </span><span class="k">new</span> <span class="nx">Code</span> <span class="nx">func</span><span class="p">.</span><span class="nx">params</span><span class="p">,</span> <span class="nx">body</span><span class="p">,</span> <span class="s">'boundfunc'</span>
|
||||
<span class="nv">bound = </span><span class="k">new</span> <span class="nx">Assign</span> <span class="nx">lhs</span><span class="p">,</span> <span class="nx">rhs</span>
|
||||
|
||||
<span class="nx">@ctor</span><span class="p">.</span><span class="nx">body</span><span class="p">.</span><span class="nx">unshift</span> <span class="nx">bound</span></pre></div> </td> </tr> <tr id="section-89"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-89">¶</a> </div> <p>{base} = assign.variable
|
||||
lhs = (new Value (new Literal "this"), [new Access base]).compile o
|
||||
@ctor.body.unshift new Literal """#{lhs} = function() {</p>
|
||||
|
||||
<h1>{o.indent} return #{@ctor.name}.prototype.#{base.value}.apply(_this, arguments);</h1>
|
||||
|
||||
<h1>{o.indent}}\n</h1>
|
||||
|
||||
<p>"""</p> </td> <td class="code"> <div class="highlight"><pre> <span class="k">return</span></pre></div> </td> </tr> <tr id="section-90"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-90">¶</a> </div> <p>Merge the properties from a top-level object as prototypal properties
|
||||
<span class="nx">@ctor</span><span class="p">.</span><span class="nx">body</span><span class="p">.</span><span class="nx">unshift</span> <span class="nx">bound</span>
|
||||
<span class="k">return</span></pre></div> </td> </tr> <tr id="section-89"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-89">¶</a> </div> <p>Merge the properties from a top-level object as prototypal properties
|
||||
on the class.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">addProperties: </span><span class="nf">(node, name, o) -></span>
|
||||
<span class="nv">props = </span><span class="nx">node</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">properties</span><span class="p">[..]</span>
|
||||
<span class="nv">exprs = </span><span class="k">while</span> <span class="nv">assign = </span><span class="nx">props</span><span class="p">.</span><span class="nx">shift</span><span class="p">()</span>
|
||||
@@ -779,7 +771,7 @@ on the class.</p> </td> <td class="code">
|
||||
<span class="nx">@boundFuncs</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="nx">base</span><span class="p">,</span> <span class="nx">func</span><span class="p">]</span>
|
||||
<span class="nv">func.bound = </span><span class="kc">no</span>
|
||||
<span class="nx">assign</span>
|
||||
<span class="nx">compact</span> <span class="nx">exprs</span></pre></div> </td> </tr> <tr id="section-91"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-91">¶</a> </div> <p>Walk the body of the class, looking for prototype properties to be converted.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">walkBody: </span><span class="nf">(name, o) -></span>
|
||||
<span class="nx">compact</span> <span class="nx">exprs</span></pre></div> </td> </tr> <tr id="section-90"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-90">¶</a> </div> <p>Walk the body of the class, looking for prototype properties to be converted.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">walkBody: </span><span class="nf">(name, o) -></span>
|
||||
<span class="nx">@traverseChildren</span> <span class="kc">false</span><span class="p">,</span> <span class="nf">(child) =></span>
|
||||
<span class="nv">cont = </span><span class="kc">true</span>
|
||||
<span class="k">return</span> <span class="kc">false</span> <span class="k">if</span> <span class="nx">child</span> <span class="k">instanceof</span> <span class="nx">Class</span>
|
||||
@@ -789,14 +781,14 @@ on the class.</p> </td> <td class="code">
|
||||
<span class="nv">cont = </span><span class="kc">false</span>
|
||||
<span class="nx">exps</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="nx">@addProperties</span> <span class="nx">node</span><span class="p">,</span> <span class="nx">name</span><span class="p">,</span> <span class="nx">o</span>
|
||||
<span class="nv">child.expressions = exps = </span><span class="nx">flatten</span> <span class="nx">exps</span>
|
||||
<span class="nx">cont</span> <span class="o">and</span> <span class="nx">child</span> <span class="o">not</span> <span class="k">instanceof</span> <span class="nx">Class</span></pre></div> </td> </tr> <tr id="section-92"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-92">¶</a> </div> <p><code>use strict</code> (and other directives) must be the first expression statement(s)
|
||||
<span class="nx">cont</span> <span class="o">and</span> <span class="nx">child</span> <span class="o">not</span> <span class="k">instanceof</span> <span class="nx">Class</span></pre></div> </td> </tr> <tr id="section-91"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-91">¶</a> </div> <p><code>use strict</code> (and other directives) must be the first expression statement(s)
|
||||
of a function body. This method ensures the prologue is correctly positioned
|
||||
above the <code>constructor</code>.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">hoistDirectivePrologue: </span><span class="nf">-></span>
|
||||
<span class="nv">index = </span><span class="mi">0</span>
|
||||
<span class="p">{</span><span class="nx">expressions</span><span class="p">}</span> <span class="o">=</span> <span class="nx">@body</span>
|
||||
<span class="o">++</span><span class="nx">index</span> <span class="k">while</span> <span class="p">(</span><span class="nv">node = </span><span class="nx">expressions</span><span class="p">[</span><span class="nx">index</span><span class="p">])</span> <span class="o">and</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Comment</span> <span class="o">or</span>
|
||||
<span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Value</span> <span class="o">and</span> <span class="nx">node</span><span class="p">.</span><span class="nx">isString</span><span class="p">()</span>
|
||||
<span class="vi">@directives = </span><span class="nx">expressions</span><span class="p">.</span><span class="nx">splice</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">index</span></pre></div> </td> </tr> <tr id="section-93"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-93">¶</a> </div> <p>Make sure that a constructor is defined for the class, and properly
|
||||
<span class="vi">@directives = </span><span class="nx">expressions</span><span class="p">.</span><span class="nx">splice</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">index</span></pre></div> </td> </tr> <tr id="section-92"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-92">¶</a> </div> <p>Make sure that a constructor is defined for the class, and properly
|
||||
configured.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">ensureConstructor: </span><span class="nf">(name) -></span>
|
||||
<span class="k">if</span> <span class="o">not</span> <span class="nx">@ctor</span>
|
||||
<span class="vi">@ctor = </span><span class="k">new</span> <span class="nx">Code</span>
|
||||
@@ -806,7 +798,7 @@ configured.</p> </td> <td class="code"> <d
|
||||
<span class="nx">@body</span><span class="p">.</span><span class="nx">expressions</span><span class="p">.</span><span class="nx">unshift</span> <span class="nx">@ctor</span>
|
||||
<span class="vi">@ctor.ctor = @ctor.name = </span><span class="nx">name</span>
|
||||
<span class="vi">@ctor.klass = </span><span class="kc">null</span>
|
||||
<span class="vi">@ctor.noReturn = </span><span class="kc">yes</span></pre></div> </td> </tr> <tr id="section-94"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-94">¶</a> </div> <p>Instead of generating the JavaScript string directly, we build up the
|
||||
<span class="vi">@ctor.noReturn = </span><span class="kc">yes</span></pre></div> </td> </tr> <tr id="section-93"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-93">¶</a> </div> <p>Instead of generating the JavaScript string directly, we build up the
|
||||
equivalent syntax tree and compile that, in pieces. You can see the
|
||||
constructor, property assignments, and inheritance getting built out below.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="nf">(o) -></span>
|
||||
<span class="nv">decl = </span><span class="nx">@determineName</span><span class="p">()</span>
|
||||
@@ -835,7 +827,7 @@ constructor, property assignments, and inheritance getting built out below.</p>
|
||||
|
||||
<span class="nv">klass = </span><span class="k">new</span> <span class="nx">Parens</span> <span class="nx">call</span><span class="p">,</span> <span class="kc">yes</span>
|
||||
<span class="nv">klass = </span><span class="k">new</span> <span class="nx">Assign</span> <span class="nx">@variable</span><span class="p">,</span> <span class="nx">klass</span> <span class="k">if</span> <span class="nx">@variable</span>
|
||||
<span class="nx">klass</span><span class="p">.</span><span class="nx">compileToFragments</span> <span class="nx">o</span></pre></div> </td> </tr> <tr id="section-95"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-95">¶</a> </div> <h3>Assign</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-96"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-96">¶</a> </div> <p>The <strong>Assign</strong> is used to assign a local variable to value, or to set the
|
||||
<span class="nx">klass</span><span class="p">.</span><span class="nx">compileToFragments</span> <span class="nx">o</span></pre></div> </td> </tr> <tr id="section-94"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-94">¶</a> </div> <h3>Assign</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-95"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-95">¶</a> </div> <p>The <strong>Assign</strong> is used to assign a local variable to value, or to set the
|
||||
property of an object -- including within object literals.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.Assign = </span><span class="k">class</span> <span class="nx">Assign</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="nv">constructor: </span><span class="nf">(@variable, @value, @context, options) -></span>
|
||||
<span class="vi">@param = </span><span class="nx">options</span> <span class="o">and</span> <span class="nx">options</span><span class="p">.</span><span class="nx">param</span>
|
||||
@@ -853,7 +845,7 @@ property of an object -- including within object literals.</p> </td>
|
||||
<span class="nx">@</span><span class="p">[</span><span class="k">if</span> <span class="nx">@context</span> <span class="o">is</span> <span class="s">'object'</span> <span class="k">then</span> <span class="s">'value'</span> <span class="k">else</span> <span class="s">'variable'</span><span class="p">].</span><span class="nx">assigns</span> <span class="nx">name</span>
|
||||
|
||||
<span class="nv">unfoldSoak: </span><span class="nf">(o) -></span>
|
||||
<span class="nx">unfoldSoak</span> <span class="nx">o</span><span class="p">,</span> <span class="k">this</span><span class="p">,</span> <span class="s">'variable'</span></pre></div> </td> </tr> <tr id="section-97"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-97">¶</a> </div> <p>Compile an assignment, delegating to <code>compilePatternMatch</code> or
|
||||
<span class="nx">unfoldSoak</span> <span class="nx">o</span><span class="p">,</span> <span class="k">this</span><span class="p">,</span> <span class="s">'variable'</span></pre></div> </td> </tr> <tr id="section-96"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-96">¶</a> </div> <p>Compile an assignment, delegating to <code>compilePatternMatch</code> or
|
||||
<code>compileSplice</code> if appropriate. Keep track of the name of the base object
|
||||
we've been assigned to, for correct internal references. If the variable
|
||||
has not been seen yet within the current scope, declare it.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="nf">(o) -></span>
|
||||
@@ -877,7 +869,7 @@ has not been seen yet within the current scope, declare it.</p> </td
|
||||
<span class="nv">val = </span><span class="nx">@value</span><span class="p">.</span><span class="nx">compileToFragments</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
|
||||
<span class="k">return</span> <span class="p">(</span><span class="nx">compiledName</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="s">": "</span><span class="p">),</span> <span class="nx">val</span><span class="p">)</span> <span class="k">if</span> <span class="nx">@context</span> <span class="o">is</span> <span class="s">'object'</span>
|
||||
<span class="nv">answer = </span><span class="nx">compiledName</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="s">" </span><span class="si">#{</span> <span class="nx">@context</span> <span class="o">or</span> <span class="s">'='</span> <span class="si">}</span><span class="s"> "</span><span class="p">),</span> <span class="nx">val</span>
|
||||
<span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o"><=</span> <span class="nx">LEVEL_LIST</span> <span class="k">then</span> <span class="nx">answer</span> <span class="k">else</span> <span class="nx">@wrapInBraces</span> <span class="nx">answer</span></pre></div> </td> </tr> <tr id="section-98"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-98">¶</a> </div> <p>Brief implementation of recursive pattern matching, when assigning array or
|
||||
<span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o"><=</span> <span class="nx">LEVEL_LIST</span> <span class="k">then</span> <span class="nx">answer</span> <span class="k">else</span> <span class="nx">@wrapInBraces</span> <span class="nx">answer</span></pre></div> </td> </tr> <tr id="section-97"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-97">¶</a> </div> <p>Brief implementation of recursive pattern matching, when assigning array or
|
||||
object literals to a value. Peeks at their properties to assign inner names.
|
||||
See the <a href="http://wiki.ecmascript.org/doku.php?id=harmony:destructuring">ECMAScript Harmony Wiki</a>
|
||||
for details.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compilePatternMatch: </span><span class="nf">(o) -></span>
|
||||
@@ -888,7 +880,7 @@ for details.</p> </td> <td class="code"> <
|
||||
<span class="nv">code = </span><span class="nx">value</span><span class="p">.</span><span class="nx">compileToFragments</span> <span class="nx">o</span>
|
||||
<span class="k">return</span> <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">>=</span> <span class="nx">LEVEL_OP</span> <span class="k">then</span> <span class="nx">@wrapInBraces</span> <span class="nx">code</span> <span class="k">else</span> <span class="nx">code</span>
|
||||
<span class="nv">isObject = </span><span class="nx">@variable</span><span class="p">.</span><span class="nx">isObject</span><span class="p">()</span>
|
||||
<span class="k">if</span> <span class="nx">top</span> <span class="o">and</span> <span class="nx">olen</span> <span class="o">is</span> <span class="mi">1</span> <span class="o">and</span> <span class="p">(</span><span class="nv">obj = </span><span class="nx">objects</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="o">not</span> <span class="k">instanceof</span> <span class="nx">Splat</span></pre></div> </td> </tr> <tr id="section-99"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-99">¶</a> </div> <p>Unroll simplest cases: <code>{v} = x</code> -> <code>v = x.v</code></p> </td> <td class="code"> <div class="highlight"><pre> <span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Assign</span>
|
||||
<span class="k">if</span> <span class="nx">top</span> <span class="o">and</span> <span class="nx">olen</span> <span class="o">is</span> <span class="mi">1</span> <span class="o">and</span> <span class="p">(</span><span class="nv">obj = </span><span class="nx">objects</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="o">not</span> <span class="k">instanceof</span> <span class="nx">Splat</span></pre></div> </td> </tr> <tr id="section-98"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-98">¶</a> </div> <p>Unroll simplest cases: <code>{v} = x</code> -> <code>v = x.v</code></p> </td> <td class="code"> <div class="highlight"><pre> <span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Assign</span>
|
||||
<span class="p">{</span><span class="nv">variable: </span><span class="p">{</span><span class="nv">base: </span><span class="nx">idx</span><span class="p">},</span> <span class="nv">value: </span><span class="nx">obj</span><span class="p">}</span> <span class="o">=</span> <span class="nx">obj</span>
|
||||
<span class="k">else</span>
|
||||
<span class="nv">idx = </span><span class="k">if</span> <span class="nx">isObject</span>
|
||||
@@ -904,14 +896,14 @@ for details.</p> </td> <td class="code"> <
|
||||
<span class="nv">vvar = </span><span class="nx">value</span><span class="p">.</span><span class="nx">compileToFragments</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
|
||||
<span class="nv">vvarText = </span><span class="nx">fragmentsToText</span> <span class="nx">vvar</span>
|
||||
<span class="nv">assigns = </span><span class="p">[]</span>
|
||||
<span class="nv">splat = </span><span class="kc">false</span></pre></div> </td> </tr> <tr id="section-100"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-100">¶</a> </div> <p>Make vvar into a simple variable if it isn't already.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="k">if</span> <span class="o">not</span> <span class="nx">IDENTIFIER</span><span class="p">.</span><span class="nx">test</span><span class="p">(</span><span class="nx">vvarText</span><span class="p">)</span> <span class="o">or</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">assigns</span><span class="p">(</span><span class="nx">vvarText</span><span class="p">)</span>
|
||||
<span class="nv">splat = </span><span class="kc">false</span></pre></div> </td> </tr> <tr id="section-99"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-99">¶</a> </div> <p>Make vvar into a simple variable if it isn't already.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="k">if</span> <span class="o">not</span> <span class="nx">IDENTIFIER</span><span class="p">.</span><span class="nx">test</span><span class="p">(</span><span class="nx">vvarText</span><span class="p">)</span> <span class="o">or</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">assigns</span><span class="p">(</span><span class="nx">vvarText</span><span class="p">)</span>
|
||||
<span class="nx">assigns</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="nx">@makeCode</span><span class="p">(</span><span class="s">"</span><span class="si">#{</span> <span class="nv">ref = </span><span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">freeVariable</span> <span class="s">'ref'</span> <span class="si">}</span><span class="s"> = "</span><span class="p">),</span> <span class="nx">vvar</span><span class="p">...]</span>
|
||||
<span class="nv">vvar = </span><span class="p">[</span><span class="nx">@makeCode</span> <span class="nx">ref</span><span class="p">]</span>
|
||||
<span class="nv">vvarText = </span><span class="nx">ref</span>
|
||||
<span class="k">for</span> <span class="nx">obj</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">objects</span></pre></div> </td> </tr> <tr id="section-101"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-101">¶</a> </div> <p>A regular array pattern-match.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">idx = </span><span class="nx">i</span>
|
||||
<span class="k">for</span> <span class="nx">obj</span><span class="p">,</span> <span class="nx">i</span> <span class="k">in</span> <span class="nx">objects</span></pre></div> </td> </tr> <tr id="section-100"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-100">¶</a> </div> <p>A regular array pattern-match.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">idx = </span><span class="nx">i</span>
|
||||
<span class="k">if</span> <span class="nx">isObject</span>
|
||||
<span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Assign</span></pre></div> </td> </tr> <tr id="section-102"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-102">¶</a> </div> <p>A regular object pattern-match.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="p">{</span><span class="nv">variable: </span><span class="p">{</span><span class="nv">base: </span><span class="nx">idx</span><span class="p">},</span> <span class="nv">value: </span><span class="nx">obj</span><span class="p">}</span> <span class="o">=</span> <span class="nx">obj</span>
|
||||
<span class="k">else</span></pre></div> </td> </tr> <tr id="section-103"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-103">¶</a> </div> <p>A shorthand <code>{a, b, @c} = val</code> pattern-match.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="k">if</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">base</span> <span class="k">instanceof</span> <span class="nx">Parens</span>
|
||||
<span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Assign</span></pre></div> </td> </tr> <tr id="section-101"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-101">¶</a> </div> <p>A regular object pattern-match.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="p">{</span><span class="nv">variable: </span><span class="p">{</span><span class="nv">base: </span><span class="nx">idx</span><span class="p">},</span> <span class="nv">value: </span><span class="nx">obj</span><span class="p">}</span> <span class="o">=</span> <span class="nx">obj</span>
|
||||
<span class="k">else</span></pre></div> </td> </tr> <tr id="section-102"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-102">¶</a> </div> <p>A shorthand <code>{a, b, @c} = val</code> pattern-match.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="k">if</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">base</span> <span class="k">instanceof</span> <span class="nx">Parens</span>
|
||||
<span class="p">[</span><span class="nx">obj</span><span class="p">,</span> <span class="nx">idx</span><span class="p">]</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Value</span><span class="p">(</span><span class="nx">obj</span><span class="p">.</span><span class="nx">unwrapAll</span><span class="p">()).</span><span class="nx">cacheReference</span> <span class="nx">o</span>
|
||||
<span class="k">else</span>
|
||||
<span class="nv">idx = </span><span class="k">if</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">this</span> <span class="k">then</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">properties</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="nx">name</span> <span class="k">else</span> <span class="nx">obj</span>
|
||||
@@ -943,14 +935,14 @@ for details.</p> </td> <td class="code"> <
|
||||
<span class="nx">assigns</span><span class="p">.</span><span class="nx">push</span> <span class="k">new</span> <span class="nx">Assign</span><span class="p">(</span><span class="nx">obj</span><span class="p">,</span> <span class="nx">val</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="nv">param: </span><span class="nx">@param</span><span class="p">,</span> <span class="nv">subpattern: </span><span class="kc">yes</span><span class="p">).</span><span class="nx">compileToFragments</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
|
||||
<span class="nx">assigns</span><span class="p">.</span><span class="nx">push</span> <span class="nx">vvar</span> <span class="k">unless</span> <span class="nx">top</span> <span class="o">or</span> <span class="nx">@subpattern</span>
|
||||
<span class="nv">fragments = </span><span class="nx">@joinFragmentArrays</span> <span class="nx">assigns</span><span class="p">,</span> <span class="s">', '</span>
|
||||
<span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o"><</span> <span class="nx">LEVEL_LIST</span> <span class="k">then</span> <span class="nx">fragments</span> <span class="k">else</span> <span class="nx">@wrapInBraces</span> <span class="nx">fragments</span></pre></div> </td> </tr> <tr id="section-104"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-104">¶</a> </div> <p>When compiling a conditional assignment, take care to ensure that the
|
||||
<span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o"><</span> <span class="nx">LEVEL_LIST</span> <span class="k">then</span> <span class="nx">fragments</span> <span class="k">else</span> <span class="nx">@wrapInBraces</span> <span class="nx">fragments</span></pre></div> </td> </tr> <tr id="section-103"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-103">¶</a> </div> <p>When compiling a conditional assignment, take care to ensure that the
|
||||
operands are only evaluated once, even though we have to reference them
|
||||
more than once.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileConditional: </span><span class="nf">(o) -></span>
|
||||
<span class="p">[</span><span class="nx">left</span><span class="p">,</span> <span class="nx">right</span><span class="p">]</span> <span class="o">=</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">cacheReference</span> <span class="nx">o</span></pre></div> </td> </tr> <tr id="section-105"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-105">¶</a> </div> <p>Disallow conditional assignment of undefined variables.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="k">if</span> <span class="o">not</span> <span class="nx">left</span><span class="p">.</span><span class="nx">properties</span><span class="p">.</span><span class="nx">length</span> <span class="o">and</span> <span class="nx">left</span><span class="p">.</span><span class="nx">base</span> <span class="k">instanceof</span> <span class="nx">Literal</span> <span class="o">and</span>
|
||||
<span class="p">[</span><span class="nx">left</span><span class="p">,</span> <span class="nx">right</span><span class="p">]</span> <span class="o">=</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">cacheReference</span> <span class="nx">o</span></pre></div> </td> </tr> <tr id="section-104"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-104">¶</a> </div> <p>Disallow conditional assignment of undefined variables.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="k">if</span> <span class="o">not</span> <span class="nx">left</span><span class="p">.</span><span class="nx">properties</span><span class="p">.</span><span class="nx">length</span> <span class="o">and</span> <span class="nx">left</span><span class="p">.</span><span class="nx">base</span> <span class="k">instanceof</span> <span class="nx">Literal</span> <span class="o">and</span>
|
||||
<span class="nx">left</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">value</span> <span class="o">!=</span> <span class="s">"this"</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">check</span> <span class="nx">left</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">value</span>
|
||||
<span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s">"the variable \"</span><span class="si">#{</span><span class="nx">left</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">value</span><span class="si">}</span><span class="s">\" can't be assigned with </span><span class="si">#{</span><span class="nx">@context</span><span class="si">}</span><span class="s"> because it has not been defined."</span>
|
||||
<span class="k">if</span> <span class="s">"?"</span> <span class="k">in</span> <span class="nx">@context</span> <span class="k">then</span> <span class="nv">o.isExistentialEquals = </span><span class="kc">true</span>
|
||||
<span class="k">new</span> <span class="nx">Op</span><span class="p">(</span><span class="nx">@context</span><span class="p">[...</span><span class="o">-</span><span class="mi">1</span><span class="p">],</span> <span class="nx">left</span><span class="p">,</span> <span class="k">new</span> <span class="nx">Assign</span><span class="p">(</span><span class="nx">right</span><span class="p">,</span> <span class="nx">@value</span><span class="p">,</span> <span class="s">'='</span><span class="p">)</span> <span class="p">).</span><span class="nx">compileToFragments</span> <span class="nx">o</span></pre></div> </td> </tr> <tr id="section-106"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-106">¶</a> </div> <p>Compile the assignment from an array splice literal, using JavaScript's
|
||||
<span class="k">new</span> <span class="nx">Op</span><span class="p">(</span><span class="nx">@context</span><span class="p">[...</span><span class="o">-</span><span class="mi">1</span><span class="p">],</span> <span class="nx">left</span><span class="p">,</span> <span class="k">new</span> <span class="nx">Assign</span><span class="p">(</span><span class="nx">right</span><span class="p">,</span> <span class="nx">@value</span><span class="p">,</span> <span class="s">'='</span><span class="p">)</span> <span class="p">).</span><span class="nx">compileToFragments</span> <span class="nx">o</span></pre></div> </td> </tr> <tr id="section-105"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-105">¶</a> </div> <p>Compile the assignment from an array splice literal, using JavaScript's
|
||||
<code>Array#splice</code> method.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileSplice: </span><span class="nf">(o) -></span>
|
||||
<span class="p">{</span><span class="nv">range: </span><span class="p">{</span><span class="nx">from</span><span class="p">,</span> <span class="nx">to</span><span class="p">,</span> <span class="nx">exclusive</span><span class="p">}}</span> <span class="o">=</span> <span class="nx">@variable</span><span class="p">.</span><span class="nx">properties</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
|
||||
<span class="nv">name = </span><span class="nx">@variable</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">o</span>
|
||||
@@ -969,7 +961,7 @@ more than once.</p> </td> <td class="code">
|
||||
<span class="nv">to = </span><span class="s">"9e9"</span>
|
||||
<span class="p">[</span><span class="nx">valDef</span><span class="p">,</span> <span class="nx">valRef</span><span class="p">]</span> <span class="o">=</span> <span class="nx">@value</span><span class="p">.</span><span class="nx">cache</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
|
||||
<span class="nv">answer = </span><span class="p">[].</span><span class="nx">concat</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="s">"[].splice.apply(</span><span class="si">#{</span><span class="nx">name</span><span class="si">}</span><span class="s">, [</span><span class="si">#{</span><span class="nx">fromDecl</span><span class="si">}</span><span class="s">, </span><span class="si">#{</span><span class="nx">to</span><span class="si">}</span><span class="s">].concat("</span><span class="p">),</span> <span class="nx">valDef</span><span class="p">,</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="s">")), "</span><span class="p">),</span> <span class="nx">valRef</span>
|
||||
<span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">></span> <span class="nx">LEVEL_TOP</span> <span class="k">then</span> <span class="nx">@wrapInBraces</span> <span class="nx">answer</span> <span class="k">else</span> <span class="nx">answer</span></pre></div> </td> </tr> <tr id="section-107"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-107">¶</a> </div> <h3>Code</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-108"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-108">¶</a> </div> <p>A function definition. This is the only node that creates a new Scope.
|
||||
<span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">></span> <span class="nx">LEVEL_TOP</span> <span class="k">then</span> <span class="nx">@wrapInBraces</span> <span class="nx">answer</span> <span class="k">else</span> <span class="nx">answer</span></pre></div> </td> </tr> <tr id="section-106"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-106">¶</a> </div> <h3>Code</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-107"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-107">¶</a> </div> <p>A function definition. This is the only node that creates a new Scope.
|
||||
When for the purposes of walking the contents of a function body, the Code
|
||||
has no <em>children</em> -- they're within the inner scope.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.Code = </span><span class="k">class</span> <span class="nx">Code</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="nv">constructor: </span><span class="nf">(params, body, tag) -></span>
|
||||
@@ -982,7 +974,7 @@ has no <em>children</em> -- they're within the inner scope.</p> </td
|
||||
|
||||
<span class="nv">isStatement: </span><span class="nf">-></span> <span class="o">!!</span><span class="nx">@ctor</span>
|
||||
|
||||
<span class="nv">jumps: </span><span class="nx">NO</span></pre></div> </td> </tr> <tr id="section-109"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-109">¶</a> </div> <p>Compilation creates a new scope unless explicitly asked to share with the
|
||||
<span class="nv">jumps: </span><span class="nx">NO</span></pre></div> </td> </tr> <tr id="section-108"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-108">¶</a> </div> <p>Compilation creates a new scope unless explicitly asked to share with the
|
||||
outer scope. Handles splat parameters in the parameter list by peeking at
|
||||
the JavaScript <code>arguments</code> object. If the function is bound with the <code>=></code>
|
||||
arrow, generates a wrapper that saves the current value of <code>this</code> through
|
||||
@@ -1044,12 +1036,12 @@ a closure.</p> </td> <td class="code"> <di
|
||||
<span class="nx">answer</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@makeCode</span> <span class="s">'}'</span>
|
||||
|
||||
<span class="k">return</span> <span class="p">[</span><span class="nx">@makeCode</span><span class="p">(</span><span class="nx">@tab</span><span class="p">),</span> <span class="nx">answer</span><span class="p">...]</span> <span class="k">if</span> <span class="nx">@ctor</span>
|
||||
<span class="k">if</span> <span class="nx">@front</span> <span class="o">or</span> <span class="p">(</span><span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">>=</span> <span class="nx">LEVEL_ACCESS</span><span class="p">)</span> <span class="k">then</span> <span class="nx">@wrapInBraces</span> <span class="nx">answer</span> <span class="k">else</span> <span class="nx">answer</span></pre></div> </td> </tr> <tr id="section-110"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-110">¶</a> </div> <p>A list of parameter names, excluding those generated by the compiler.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">paramNames: </span><span class="nf">-></span>
|
||||
<span class="k">if</span> <span class="nx">@front</span> <span class="o">or</span> <span class="p">(</span><span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">>=</span> <span class="nx">LEVEL_ACCESS</span><span class="p">)</span> <span class="k">then</span> <span class="nx">@wrapInBraces</span> <span class="nx">answer</span> <span class="k">else</span> <span class="nx">answer</span></pre></div> </td> </tr> <tr id="section-109"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-109">¶</a> </div> <p>A list of parameter names, excluding those generated by the compiler.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">paramNames: </span><span class="nf">-></span>
|
||||
<span class="nv">names = </span><span class="p">[]</span>
|
||||
<span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">param</span><span class="p">.</span><span class="nx">names</span><span class="p">()...</span> <span class="k">for</span> <span class="nx">param</span> <span class="k">in</span> <span class="nx">@params</span>
|
||||
<span class="nx">names</span></pre></div> </td> </tr> <tr id="section-111"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-111">¶</a> </div> <p>Short-circuit <code>traverseChildren</code> method to prevent it from crossing scope boundaries
|
||||
<span class="nx">names</span></pre></div> </td> </tr> <tr id="section-110"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-110">¶</a> </div> <p>Short-circuit <code>traverseChildren</code> method to prevent it from crossing scope boundaries
|
||||
unless <code>crossScope</code> is <code>true</code>.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">traverseChildren: </span><span class="nf">(crossScope, func) -></span>
|
||||
<span class="k">super</span><span class="p">(</span><span class="nx">crossScope</span><span class="p">,</span> <span class="nx">func</span><span class="p">)</span> <span class="k">if</span> <span class="nx">crossScope</span></pre></div> </td> </tr> <tr id="section-112"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-112">¶</a> </div> <h3>Param</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-113"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-113">¶</a> </div> <p>A parameter in a function definition. Beyond a typical Javascript parameter,
|
||||
<span class="k">super</span><span class="p">(</span><span class="nx">crossScope</span><span class="p">,</span> <span class="nx">func</span><span class="p">)</span> <span class="k">if</span> <span class="nx">crossScope</span></pre></div> </td> </tr> <tr id="section-111"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-111">¶</a> </div> <h3>Param</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-112"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-112">¶</a> </div> <p>A parameter in a function definition. Beyond a typical Javascript parameter,
|
||||
these parameters can also attach themselves to the context of the function,
|
||||
as well as be a splat, gathering up a group of parameters into an array.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.Param = </span><span class="k">class</span> <span class="nx">Param</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="nv">constructor: </span><span class="nf">(@name, @value, @splat) -></span>
|
||||
@@ -1075,7 +1067,7 @@ as well as be a splat, gathering up a group of parameters into an array.</p>
|
||||
<span class="vi">@reference = </span><span class="nx">node</span>
|
||||
|
||||
<span class="nv">isComplex: </span><span class="nf">-></span>
|
||||
<span class="nx">@name</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span></pre></div> </td> </tr> <tr id="section-114"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-114">¶</a> </div> <p>Finds the name or names of a <code>Param</code>; useful for detecting duplicates.
|
||||
<span class="nx">@name</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span></pre></div> </td> </tr> <tr id="section-113"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-113">¶</a> </div> <p>Finds the name or names of a <code>Param</code>; useful for detecting duplicates.
|
||||
In a sense, a destructured parameter represents multiple JS parameters,
|
||||
thus this method returns an <code>Array</code> of names.
|
||||
Reserved words used as param names, as well as the Object and Array
|
||||
@@ -1084,31 +1076,31 @@ during the <code>Code</code> compilation step, so this is necessarily an incompl
|
||||
list of a parameter's names.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">names: </span><span class="nf">(name = @name)-></span>
|
||||
<span class="nv">atParam = </span><span class="nf">(obj) -></span>
|
||||
<span class="p">{</span><span class="nx">value</span><span class="p">}</span> <span class="o">=</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">properties</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="nx">name</span>
|
||||
<span class="k">return</span> <span class="k">if</span> <span class="nx">value</span><span class="p">.</span><span class="nx">reserved</span> <span class="k">then</span> <span class="p">[]</span> <span class="k">else</span> <span class="p">[</span><span class="nx">value</span><span class="p">]</span></pre></div> </td> </tr> <tr id="section-115"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-115">¶</a> </div> <ul>
|
||||
<span class="k">return</span> <span class="k">if</span> <span class="nx">value</span><span class="p">.</span><span class="nx">reserved</span> <span class="k">then</span> <span class="p">[]</span> <span class="k">else</span> <span class="p">[</span><span class="nx">value</span><span class="p">]</span></pre></div> </td> </tr> <tr id="section-114"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-114">¶</a> </div> <ul>
|
||||
<li>simple literals <code>foo</code></li>
|
||||
</ul> </td> <td class="code"> <div class="highlight"><pre> <span class="k">return</span> <span class="p">[</span><span class="nx">name</span><span class="p">.</span><span class="nx">value</span><span class="p">]</span> <span class="k">if</span> <span class="nx">name</span> <span class="k">instanceof</span> <span class="nx">Literal</span></pre></div> </td> </tr> <tr id="section-116"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-116">¶</a> </div> <ul>
|
||||
</ul> </td> <td class="code"> <div class="highlight"><pre> <span class="k">return</span> <span class="p">[</span><span class="nx">name</span><span class="p">.</span><span class="nx">value</span><span class="p">]</span> <span class="k">if</span> <span class="nx">name</span> <span class="k">instanceof</span> <span class="nx">Literal</span></pre></div> </td> </tr> <tr id="section-115"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-115">¶</a> </div> <ul>
|
||||
<li>at-params <code>@foo</code></li>
|
||||
</ul> </td> <td class="code"> <div class="highlight"><pre> <span class="k">return</span> <span class="nx">atParam</span><span class="p">(</span><span class="nx">name</span><span class="p">)</span> <span class="k">if</span> <span class="nx">name</span> <span class="k">instanceof</span> <span class="nx">Value</span>
|
||||
<span class="nv">names = </span><span class="p">[]</span>
|
||||
<span class="k">for</span> <span class="nx">obj</span> <span class="k">in</span> <span class="nx">name</span><span class="p">.</span><span class="nx">objects</span></pre></div> </td> </tr> <tr id="section-117"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-117">¶</a> </div> <ul>
|
||||
<span class="k">for</span> <span class="nx">obj</span> <span class="k">in</span> <span class="nx">name</span><span class="p">.</span><span class="nx">objects</span></pre></div> </td> </tr> <tr id="section-116"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-116">¶</a> </div> <ul>
|
||||
<li>assignments within destructured parameters <code>{foo:bar}</code></li>
|
||||
</ul> </td> <td class="code"> <div class="highlight"><pre> <span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Assign</span>
|
||||
<span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@names</span><span class="p">(</span><span class="nx">obj</span><span class="p">.</span><span class="nx">value</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">())...</span></pre></div> </td> </tr> <tr id="section-118"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-118">¶</a> </div> <ul>
|
||||
<span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@names</span><span class="p">(</span><span class="nx">obj</span><span class="p">.</span><span class="nx">value</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">())...</span></pre></div> </td> </tr> <tr id="section-117"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-117">¶</a> </div> <ul>
|
||||
<li>splats within destructured parameters <code>[xs...]</code></li>
|
||||
</ul> </td> <td class="code"> <div class="highlight"><pre> <span class="k">else</span> <span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Splat</span>
|
||||
<span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">name</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">().</span><span class="nx">value</span>
|
||||
<span class="k">else</span> <span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Value</span></pre></div> </td> </tr> <tr id="section-119"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-119">¶</a> </div> <ul>
|
||||
<span class="k">else</span> <span class="k">if</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Value</span></pre></div> </td> </tr> <tr id="section-118"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-118">¶</a> </div> <ul>
|
||||
<li>destructured parameters within destructured parameters <code>[{a}]</code></li>
|
||||
</ul> </td> <td class="code"> <div class="highlight"><pre> <span class="k">if</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">isArray</span><span class="p">()</span> <span class="o">or</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">isObject</span><span class="p">()</span>
|
||||
<span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@names</span><span class="p">(</span><span class="nx">obj</span><span class="p">.</span><span class="nx">base</span><span class="p">)...</span></pre></div> </td> </tr> <tr id="section-120"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-120">¶</a> </div> <ul>
|
||||
<span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@names</span><span class="p">(</span><span class="nx">obj</span><span class="p">.</span><span class="nx">base</span><span class="p">)...</span></pre></div> </td> </tr> <tr id="section-119"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-119">¶</a> </div> <ul>
|
||||
<li>at-params within destructured parameters <code>{@foo}</code></li>
|
||||
</ul> </td> <td class="code"> <div class="highlight"><pre> <span class="k">else</span> <span class="k">if</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">this</span>
|
||||
<span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">atParam</span><span class="p">(</span><span class="nx">obj</span><span class="p">)...</span></pre></div> </td> </tr> <tr id="section-121"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-121">¶</a> </div> <ul>
|
||||
<span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">atParam</span><span class="p">(</span><span class="nx">obj</span><span class="p">)...</span></pre></div> </td> </tr> <tr id="section-120"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-120">¶</a> </div> <ul>
|
||||
<li>simple destructured parameters {foo}</li>
|
||||
</ul> </td> <td class="code"> <div class="highlight"><pre> <span class="k">else</span> <span class="nx">names</span><span class="p">.</span><span class="nx">push</span> <span class="nx">obj</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">value</span>
|
||||
<span class="k">else</span>
|
||||
<span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s">"illegal parameter </span><span class="si">#{</span><span class="nx">obj</span><span class="p">.</span><span class="nx">compile</span><span class="p">()</span><span class="si">}</span><span class="s">"</span>
|
||||
<span class="nx">names</span></pre></div> </td> </tr> <tr id="section-122"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-122">¶</a> </div> <h3>Splat</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-123"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-123">¶</a> </div> <p>A splat, either as a parameter to a function, an argument to a call,
|
||||
<span class="nx">names</span></pre></div> </td> </tr> <tr id="section-121"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-121">¶</a> </div> <h3>Splat</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-122"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-122">¶</a> </div> <p>A splat, either as a parameter to a function, an argument to a call,
|
||||
or as part of a destructuring assignment.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.Splat = </span><span class="k">class</span> <span class="nx">Splat</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
|
||||
<span class="nv">children: </span><span class="p">[</span><span class="s">'name'</span><span class="p">]</span>
|
||||
@@ -1124,7 +1116,7 @@ or as part of a destructuring assignment.</p> </td> <td
|
||||
<span class="nv">compileToFragments: </span><span class="nf">(o) -></span>
|
||||
<span class="nx">@name</span><span class="p">.</span><span class="nx">compileToFragments</span> <span class="nx">o</span>
|
||||
|
||||
<span class="nv">unwrap: </span><span class="nf">-></span> <span class="nx">@name</span></pre></div> </td> </tr> <tr id="section-124"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-124">¶</a> </div> <p>Utility function that converts an arbitrary number of elements, mixed with
|
||||
<span class="nv">unwrap: </span><span class="nf">-></span> <span class="nx">@name</span></pre></div> </td> </tr> <tr id="section-123"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-123">¶</a> </div> <p>Utility function that converts an arbitrary number of elements, mixed with
|
||||
splats, to a proper array.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="vi">@compileSplattedArray: </span><span class="nf">(o, list, apply) -></span>
|
||||
<span class="nv">index = </span><span class="o">-</span><span class="mi">1</span>
|
||||
<span class="k">continue</span> <span class="k">while</span> <span class="p">(</span><span class="nv">node = </span><span class="nx">list</span><span class="p">[</span><span class="o">++</span><span class="nx">index</span><span class="p">])</span> <span class="o">and</span> <span class="nx">node</span> <span class="o">not</span> <span class="k">instanceof</span> <span class="nx">Splat</span>
|
||||
@@ -1147,7 +1139,7 @@ splats, to a proper array.</p> </td> <td class="code">
|
||||
<span class="nv">base = </span><span class="p">(</span><span class="nx">node</span><span class="p">.</span><span class="nx">compileToFragments</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span> <span class="k">for</span> <span class="nx">node</span> <span class="k">in</span> <span class="nx">list</span><span class="p">[...</span><span class="nx">index</span><span class="p">])</span>
|
||||
<span class="nv">base = </span><span class="nx">list</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="nx">joinFragmentArrays</span> <span class="nx">base</span><span class="p">,</span> <span class="s">', '</span>
|
||||
<span class="nv">concatPart = </span><span class="nx">list</span><span class="p">[</span><span class="nx">index</span><span class="p">].</span><span class="nx">joinFragmentArrays</span> <span class="nx">args</span><span class="p">,</span> <span class="s">', '</span>
|
||||
<span class="p">[].</span><span class="nx">concat</span> <span class="nx">list</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="nx">makeCode</span><span class="p">(</span><span class="s">"["</span><span class="p">),</span> <span class="nx">base</span><span class="p">,</span> <span class="nx">list</span><span class="p">[</span><span class="nx">index</span><span class="p">].</span><span class="nx">makeCode</span><span class="p">(</span><span class="s">"].concat("</span><span class="p">),</span> <span class="nx">concatPart</span><span class="p">,</span> <span class="p">(</span><span class="nx">last</span> <span class="nx">list</span><span class="p">).</span><span class="nx">makeCode</span><span class="p">(</span><span class="s">")"</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-125"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-125">¶</a> </div> <h3>While</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-126"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-126">¶</a> </div> <p>A while loop, the only sort of low-level loop exposed by CoffeeScript. From
|
||||
<span class="p">[].</span><span class="nx">concat</span> <span class="nx">list</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="nx">makeCode</span><span class="p">(</span><span class="s">"["</span><span class="p">),</span> <span class="nx">base</span><span class="p">,</span> <span class="nx">list</span><span class="p">[</span><span class="nx">index</span><span class="p">].</span><span class="nx">makeCode</span><span class="p">(</span><span class="s">"].concat("</span><span class="p">),</span> <span class="nx">concatPart</span><span class="p">,</span> <span class="p">(</span><span class="nx">last</span> <span class="nx">list</span><span class="p">).</span><span class="nx">makeCode</span><span class="p">(</span><span class="s">")"</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-124"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-124">¶</a> </div> <h3>While</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-125"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-125">¶</a> </div> <p>A while loop, the only sort of low-level loop exposed by CoffeeScript. From
|
||||
it, all other loops can be manufactured. Useful in cases where you need more
|
||||
flexibility or more speed than a comprehension can provide.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.While = </span><span class="k">class</span> <span class="nx">While</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="nv">constructor: </span><span class="nf">(condition, options) -></span>
|
||||
@@ -1173,7 +1165,7 @@ flexibility or more speed than a comprehension can provide.</p> </td
|
||||
<span class="k">return</span> <span class="kc">no</span> <span class="k">unless</span> <span class="nx">expressions</span><span class="p">.</span><span class="nx">length</span>
|
||||
<span class="k">for</span> <span class="nx">node</span> <span class="k">in</span> <span class="nx">expressions</span>
|
||||
<span class="k">return</span> <span class="nx">node</span> <span class="k">if</span> <span class="nx">node</span><span class="p">.</span><span class="nx">jumps</span> <span class="k">loop</span><span class="o">:</span> <span class="kc">yes</span>
|
||||
<span class="kc">no</span></pre></div> </td> </tr> <tr id="section-127"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-127">¶</a> </div> <p>The main difference from a JavaScript <em>while</em> is that the CoffeeScript
|
||||
<span class="kc">no</span></pre></div> </td> </tr> <tr id="section-126"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-126">¶</a> </div> <p>The main difference from a JavaScript <em>while</em> is that the CoffeeScript
|
||||
<em>while</em> can be used as a part of a larger expression -- while loops may
|
||||
return an array containing the computed result of each iteration.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="nf">(o) -></span>
|
||||
<span class="nx">o</span><span class="p">.</span><span class="nx">indent</span> <span class="o">+=</span> <span class="nx">TAB</span>
|
||||
@@ -1195,7 +1187,7 @@ return an array containing the computed result of each iteration.</p>
|
||||
<span class="nx">@makeCode</span><span class="p">(</span><span class="s">") {"</span><span class="p">),</span> <span class="nx">body</span><span class="p">,</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="s">"}"</span><span class="p">)</span>
|
||||
<span class="k">if</span> <span class="nx">@returns</span>
|
||||
<span class="nx">answer</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@makeCode</span> <span class="s">"\n</span><span class="si">#{</span><span class="nx">@tab</span><span class="si">}</span><span class="s">return </span><span class="si">#{</span><span class="nx">rvar</span><span class="si">}</span><span class="s">;"</span>
|
||||
<span class="nx">answer</span></pre></div> </td> </tr> <tr id="section-128"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-128">¶</a> </div> <h3>Op</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-129"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-129">¶</a> </div> <p>Simple Arithmetic and logical operations. Performs some conversion from
|
||||
<span class="nx">answer</span></pre></div> </td> </tr> <tr id="section-127"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-127">¶</a> </div> <h3>Op</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-128"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-128">¶</a> </div> <p>Simple Arithmetic and logical operations. Performs some conversion from
|
||||
CoffeeScript operations into their JavaScript equivalents.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.Op = </span><span class="k">class</span> <span class="nx">Op</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="nv">constructor: </span><span class="nf">(op, first, second, flip ) -></span>
|
||||
<span class="k">return</span> <span class="k">new</span> <span class="nx">In</span> <span class="nx">first</span><span class="p">,</span> <span class="nx">second</span> <span class="k">if</span> <span class="nx">op</span> <span class="o">is</span> <span class="s">'in'</span>
|
||||
@@ -1208,10 +1200,10 @@ CoffeeScript operations into their JavaScript equivalents.</p> </td>
|
||||
<span class="vi">@first = </span><span class="nx">first</span>
|
||||
<span class="vi">@second = </span><span class="nx">second</span>
|
||||
<span class="vi">@flip = </span><span class="o">!!</span><span class="nx">flip</span>
|
||||
<span class="k">return</span> <span class="k">this</span></pre></div> </td> </tr> <tr id="section-130"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-130">¶</a> </div> <p>The map of conversions from CoffeeScript to JavaScript symbols.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">CONVERSIONS =</span>
|
||||
<span class="k">return</span> <span class="k">this</span></pre></div> </td> </tr> <tr id="section-129"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-129">¶</a> </div> <p>The map of conversions from CoffeeScript to JavaScript symbols.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">CONVERSIONS =</span>
|
||||
<span class="s">'=='</span><span class="o">:</span> <span class="s">'==='</span>
|
||||
<span class="s">'!='</span><span class="o">:</span> <span class="s">'!=='</span>
|
||||
<span class="s">'of'</span><span class="o">:</span> <span class="s">'in'</span></pre></div> </td> </tr> <tr id="section-131"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-131">¶</a> </div> <p>The map of invertible operators.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">INVERSIONS =</span>
|
||||
<span class="s">'of'</span><span class="o">:</span> <span class="s">'in'</span></pre></div> </td> </tr> <tr id="section-130"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-130">¶</a> </div> <p>The map of invertible operators.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">INVERSIONS =</span>
|
||||
<span class="s">'!=='</span><span class="o">:</span> <span class="s">'==='</span>
|
||||
<span class="s">'==='</span><span class="o">:</span> <span class="s">'!=='</span>
|
||||
|
||||
@@ -1223,7 +1215,7 @@ CoffeeScript operations into their JavaScript equivalents.</p> </td>
|
||||
<span class="o">not</span> <span class="nx">@second</span>
|
||||
|
||||
<span class="nv">isComplex: </span><span class="nf">-></span>
|
||||
<span class="o">not</span> <span class="p">(</span><span class="nx">@isUnary</span><span class="p">()</span> <span class="o">and</span> <span class="p">(</span><span class="nx">@operator</span> <span class="k">in</span> <span class="p">[</span><span class="s">'+'</span><span class="p">,</span> <span class="s">'-'</span><span class="p">]))</span> <span class="o">or</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span></pre></div> </td> </tr> <tr id="section-132"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-132">¶</a> </div> <p>Am I capable of
|
||||
<span class="o">not</span> <span class="p">(</span><span class="nx">@isUnary</span><span class="p">()</span> <span class="o">and</span> <span class="p">(</span><span class="nx">@operator</span> <span class="k">in</span> <span class="p">[</span><span class="s">'+'</span><span class="p">,</span> <span class="s">'-'</span><span class="p">]))</span> <span class="o">or</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">isComplex</span><span class="p">()</span></pre></div> </td> </tr> <tr id="section-131"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-131">¶</a> </div> <p>Am I capable of
|
||||
<a href="http://docs.python.org/reference/expressions.html#notin">Python-style comparison chaining</a>?</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">isChainable: </span><span class="nf">-></span>
|
||||
<span class="nx">@operator</span> <span class="k">in</span> <span class="p">[</span><span class="s">'<'</span><span class="p">,</span> <span class="s">'>'</span><span class="p">,</span> <span class="s">'>='</span><span class="p">,</span> <span class="s">'<='</span><span class="p">,</span> <span class="s">'==='</span><span class="p">,</span> <span class="s">'!=='</span><span class="p">]</span>
|
||||
|
||||
@@ -1274,7 +1266,7 @@ CoffeeScript operations into their JavaScript equivalents.</p> </td>
|
||||
<span class="nx">call</span>
|
||||
|
||||
<span class="nv">compileNode: </span><span class="nf">(o) -></span>
|
||||
<span class="nv">isChain = </span><span class="nx">@isChainable</span><span class="p">()</span> <span class="o">and</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">isChainable</span><span class="p">()</span></pre></div> </td> </tr> <tr id="section-133"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-133">¶</a> </div> <p>In chains, there's no need to wrap bare obj literals in parens,
|
||||
<span class="nv">isChain = </span><span class="nx">@isChainable</span><span class="p">()</span> <span class="o">and</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">isChainable</span><span class="p">()</span></pre></div> </td> </tr> <tr id="section-132"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-132">¶</a> </div> <p>In chains, there's no need to wrap bare obj literals in parens,
|
||||
as the chained expression is wrapped.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="vi">@first.front = </span><span class="nx">@front</span> <span class="k">unless</span> <span class="nx">isChain</span>
|
||||
<span class="k">if</span> <span class="nx">@operator</span> <span class="o">is</span> <span class="s">'delete'</span> <span class="o">and</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">check</span><span class="p">(</span><span class="nx">@first</span><span class="p">.</span><span class="nx">unwrapAll</span><span class="p">().</span><span class="nx">value</span><span class="p">)</span>
|
||||
<span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s">'delete operand may not be argument or var'</span>
|
||||
@@ -1285,7 +1277,7 @@ as the chained expression is wrapped.</p> </td> <td clas
|
||||
<span class="k">return</span> <span class="nx">@compileExistence</span> <span class="nx">o</span> <span class="k">if</span> <span class="nx">@operator</span> <span class="o">is</span> <span class="s">'?'</span>
|
||||
<span class="nv">answer = </span><span class="p">[].</span><span class="nx">concat</span> <span class="nx">@first</span><span class="p">.</span><span class="nx">compileToFragments</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_OP</span><span class="p">),</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="s">' '</span> <span class="o">+</span> <span class="nx">@operator</span> <span class="o">+</span> <span class="s">' '</span><span class="p">),</span>
|
||||
<span class="nx">@second</span><span class="p">.</span><span class="nx">compileToFragments</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_OP</span><span class="p">)</span>
|
||||
<span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o"><=</span> <span class="nx">LEVEL_OP</span> <span class="k">then</span> <span class="nx">answer</span> <span class="k">else</span> <span class="nx">@wrapInBraces</span> <span class="nx">answer</span></pre></div> </td> </tr> <tr id="section-134"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-134">¶</a> </div> <p>Mimic Python's chained comparisons when multiple comparison operators are
|
||||
<span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o"><=</span> <span class="nx">LEVEL_OP</span> <span class="k">then</span> <span class="nx">answer</span> <span class="k">else</span> <span class="nx">@wrapInBraces</span> <span class="nx">answer</span></pre></div> </td> </tr> <tr id="section-133"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-133">¶</a> </div> <p>Mimic Python's chained comparisons when multiple comparison operators are
|
||||
used sequentially. For example:</p>
|
||||
|
||||
<pre><code>bin/coffee -e 'console.log 50 < 65 > 10'
|
||||
@@ -1304,7 +1296,7 @@ true
|
||||
<span class="k">else</span>
|
||||
<span class="nv">fst = </span><span class="nx">@first</span>
|
||||
<span class="nv">ref = </span><span class="nx">fst</span>
|
||||
<span class="k">new</span> <span class="nx">If</span><span class="p">(</span><span class="k">new</span> <span class="nx">Existence</span><span class="p">(</span><span class="nx">fst</span><span class="p">),</span> <span class="nx">ref</span><span class="p">,</span> <span class="nv">type: </span><span class="s">'if'</span><span class="p">).</span><span class="nx">addElse</span><span class="p">(</span><span class="nx">@second</span><span class="p">).</span><span class="nx">compileToFragments</span> <span class="nx">o</span></pre></div> </td> </tr> <tr id="section-135"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-135">¶</a> </div> <p>Compile a unary <strong>Op</strong>.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileUnary: </span><span class="nf">(o) -></span>
|
||||
<span class="k">new</span> <span class="nx">If</span><span class="p">(</span><span class="k">new</span> <span class="nx">Existence</span><span class="p">(</span><span class="nx">fst</span><span class="p">),</span> <span class="nx">ref</span><span class="p">,</span> <span class="nv">type: </span><span class="s">'if'</span><span class="p">).</span><span class="nx">addElse</span><span class="p">(</span><span class="nx">@second</span><span class="p">).</span><span class="nx">compileToFragments</span> <span class="nx">o</span></pre></div> </td> </tr> <tr id="section-134"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-134">¶</a> </div> <p>Compile a unary <strong>Op</strong>.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileUnary: </span><span class="nf">(o) -></span>
|
||||
<span class="nv">parts = </span><span class="p">[]</span>
|
||||
<span class="nv">op = </span><span class="nx">@operator</span>
|
||||
<span class="nx">parts</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="nx">@makeCode</span> <span class="nx">op</span><span class="p">]</span>
|
||||
@@ -1323,7 +1315,7 @@ true
|
||||
<span class="nx">@joinFragmentArrays</span> <span class="nx">parts</span><span class="p">,</span> <span class="s">''</span>
|
||||
|
||||
<span class="nv">toString: </span><span class="nf">(idt) -></span>
|
||||
<span class="k">super</span> <span class="nx">idt</span><span class="p">,</span> <span class="nx">@constructor</span><span class="p">.</span><span class="nx">name</span> <span class="o">+</span> <span class="s">' '</span> <span class="o">+</span> <span class="nx">@operator</span></pre></div> </td> </tr> <tr id="section-136"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-136">¶</a> </div> <h3>In</h3> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.In = </span><span class="k">class</span> <span class="nx">In</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="k">super</span> <span class="nx">idt</span><span class="p">,</span> <span class="nx">@constructor</span><span class="p">.</span><span class="nx">name</span> <span class="o">+</span> <span class="s">' '</span> <span class="o">+</span> <span class="nx">@operator</span></pre></div> </td> </tr> <tr id="section-135"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-135">¶</a> </div> <h3>In</h3> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.In = </span><span class="k">class</span> <span class="nx">In</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="nv">constructor: </span><span class="nf">(@object, @array) -></span>
|
||||
|
||||
<span class="nv">children: </span><span class="p">[</span><span class="s">'object'</span><span class="p">,</span> <span class="s">'array'</span><span class="p">]</span>
|
||||
@@ -1334,7 +1326,7 @@ true
|
||||
<span class="k">if</span> <span class="nx">@array</span> <span class="k">instanceof</span> <span class="nx">Value</span> <span class="o">and</span> <span class="nx">@array</span><span class="p">.</span><span class="nx">isArray</span><span class="p">()</span>
|
||||
<span class="k">for</span> <span class="nx">obj</span> <span class="k">in</span> <span class="nx">@array</span><span class="p">.</span><span class="nx">base</span><span class="p">.</span><span class="nx">objects</span> <span class="k">when</span> <span class="nx">obj</span> <span class="k">instanceof</span> <span class="nx">Splat</span>
|
||||
<span class="nv">hasSplat = </span><span class="kc">yes</span>
|
||||
<span class="k">break</span></pre></div> </td> </tr> <tr id="section-137"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-137">¶</a> </div> <p><code>compileOrTest</code> only if we have an array literal with no splats</p> </td> <td class="code"> <div class="highlight"><pre> <span class="k">return</span> <span class="nx">@compileOrTest</span> <span class="nx">o</span> <span class="k">unless</span> <span class="nx">hasSplat</span>
|
||||
<span class="k">break</span></pre></div> </td> </tr> <tr id="section-136"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-136">¶</a> </div> <p><code>compileOrTest</code> only if we have an array literal with no splats</p> </td> <td class="code"> <div class="highlight"><pre> <span class="k">return</span> <span class="nx">@compileOrTest</span> <span class="nx">o</span> <span class="k">unless</span> <span class="nx">hasSplat</span>
|
||||
<span class="nx">@compileLoopTest</span> <span class="nx">o</span>
|
||||
|
||||
<span class="nv">compileOrTest: </span><span class="nf">(o) -></span>
|
||||
@@ -1356,7 +1348,7 @@ true
|
||||
<span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o"><</span> <span class="nx">LEVEL_LIST</span> <span class="k">then</span> <span class="nx">fragments</span> <span class="k">else</span> <span class="nx">@wrapInBraces</span> <span class="nx">fragments</span>
|
||||
|
||||
<span class="nv">toString: </span><span class="nf">(idt) -></span>
|
||||
<span class="k">super</span> <span class="nx">idt</span><span class="p">,</span> <span class="nx">@constructor</span><span class="p">.</span><span class="nx">name</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">@negated</span> <span class="k">then</span> <span class="s">'!'</span> <span class="k">else</span> <span class="s">''</span></pre></div> </td> </tr> <tr id="section-138"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-138">¶</a> </div> <h3>Try</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-139"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-139">¶</a> </div> <p>A classic <em>try/catch/finally</em> block.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.Try = </span><span class="k">class</span> <span class="nx">Try</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="k">super</span> <span class="nx">idt</span><span class="p">,</span> <span class="nx">@constructor</span><span class="p">.</span><span class="nx">name</span> <span class="o">+</span> <span class="k">if</span> <span class="nx">@negated</span> <span class="k">then</span> <span class="s">'!'</span> <span class="k">else</span> <span class="s">''</span></pre></div> </td> </tr> <tr id="section-137"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-137">¶</a> </div> <h3>Try</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-138"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-138">¶</a> </div> <p>A classic <em>try/catch/finally</em> block.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.Try = </span><span class="k">class</span> <span class="nx">Try</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="nv">constructor: </span><span class="nf">(@attempt, @error, @recovery, @ensure) -></span>
|
||||
|
||||
<span class="nv">children: </span><span class="p">[</span><span class="s">'attempt'</span><span class="p">,</span> <span class="s">'recovery'</span><span class="p">,</span> <span class="s">'ensure'</span><span class="p">]</span>
|
||||
@@ -1368,7 +1360,7 @@ true
|
||||
<span class="nv">makeReturn: </span><span class="nf">(res) -></span>
|
||||
<span class="vi">@attempt = </span><span class="nx">@attempt</span> <span class="p">.</span><span class="nx">makeReturn</span> <span class="nx">res</span> <span class="k">if</span> <span class="nx">@attempt</span>
|
||||
<span class="vi">@recovery = </span><span class="nx">@recovery</span><span class="p">.</span><span class="nx">makeReturn</span> <span class="nx">res</span> <span class="k">if</span> <span class="nx">@recovery</span>
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-140"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-140">¶</a> </div> <p>Compilation is more or less as you would expect -- the <em>finally</em> clause
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-139"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-139">¶</a> </div> <p>Compilation is more or less as you would expect -- the <em>finally</em> clause
|
||||
is optional, the <em>catch</em> is not.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="nf">(o) -></span>
|
||||
<span class="nx">o</span><span class="p">.</span><span class="nx">indent</span> <span class="o">+=</span> <span class="nx">TAB</span>
|
||||
<span class="nv">tryPart = </span><span class="nx">@attempt</span><span class="p">.</span><span class="nx">compileToFragments</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_TOP</span>
|
||||
@@ -1392,16 +1384,16 @@ is optional, the <em>catch</em> is not.</p> </td> <td cl
|
||||
|
||||
<span class="p">[].</span><span class="nx">concat</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="s">"</span><span class="si">#{</span><span class="nx">@tab</span><span class="si">}</span><span class="s">try {\n"</span><span class="p">),</span>
|
||||
<span class="nx">tryPart</span><span class="p">,</span>
|
||||
<span class="nx">@makeCode</span><span class="p">(</span><span class="s">"\n</span><span class="si">#{</span><span class="nx">@tab</span><span class="si">}</span><span class="s">}"</span><span class="p">),</span> <span class="nx">catchPart</span><span class="p">,</span> <span class="nx">ensurePart</span></pre></div> </td> </tr> <tr id="section-141"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-141">¶</a> </div> <h3>Throw</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-142"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-142">¶</a> </div> <p>Simple node to throw an exception.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.Throw = </span><span class="k">class</span> <span class="nx">Throw</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="nx">@makeCode</span><span class="p">(</span><span class="s">"\n</span><span class="si">#{</span><span class="nx">@tab</span><span class="si">}</span><span class="s">}"</span><span class="p">),</span> <span class="nx">catchPart</span><span class="p">,</span> <span class="nx">ensurePart</span></pre></div> </td> </tr> <tr id="section-140"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-140">¶</a> </div> <h3>Throw</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-141"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-141">¶</a> </div> <p>Simple node to throw an exception.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.Throw = </span><span class="k">class</span> <span class="nx">Throw</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="nv">constructor: </span><span class="nf">(@expression) -></span>
|
||||
|
||||
<span class="nv">children: </span><span class="p">[</span><span class="s">'expression'</span><span class="p">]</span>
|
||||
|
||||
<span class="nv">isStatement: </span><span class="nx">YES</span>
|
||||
<span class="nv">jumps: </span> <span class="nx">NO</span></pre></div> </td> </tr> <tr id="section-143"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-143">¶</a> </div> <p>A <strong>Throw</strong> is already a return, of sorts...</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">makeReturn: </span><span class="nx">THIS</span>
|
||||
<span class="nv">jumps: </span> <span class="nx">NO</span></pre></div> </td> </tr> <tr id="section-142"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-142">¶</a> </div> <p>A <strong>Throw</strong> is already a return, of sorts...</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">makeReturn: </span><span class="nx">THIS</span>
|
||||
|
||||
<span class="nv">compileNode: </span><span class="nf">(o) -></span>
|
||||
<span class="p">[].</span><span class="nx">concat</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="nx">@tab</span> <span class="o">+</span> <span class="s">"throw "</span><span class="p">),</span> <span class="p">(</span><span class="nx">@expression</span><span class="p">.</span><span class="nx">compileToFragments</span> <span class="nx">o</span><span class="p">),</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="s">";"</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-144"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-144">¶</a> </div> <h3>Existence</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-145"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-145">¶</a> </div> <p>Checks a variable for existence -- not <em>null</em> and not <em>undefined</em>. This is
|
||||
<span class="p">[].</span><span class="nx">concat</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="nx">@tab</span> <span class="o">+</span> <span class="s">"throw "</span><span class="p">),</span> <span class="p">(</span><span class="nx">@expression</span><span class="p">.</span><span class="nx">compileToFragments</span> <span class="nx">o</span><span class="p">),</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="s">";"</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-143"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-143">¶</a> </div> <h3>Existence</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-144"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-144">¶</a> </div> <p>Checks a variable for existence -- not <em>null</em> and not <em>undefined</em>. This is
|
||||
similar to <code>.nil?</code> in Ruby, and avoids having to consult a JavaScript truth
|
||||
table.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.Existence = </span><span class="k">class</span> <span class="nx">Existence</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="nv">constructor: </span><span class="nf">(@expression) -></span>
|
||||
@@ -1416,8 +1408,8 @@ table.</p> </td> <td class="code"> <div cl
|
||||
<span class="k">if</span> <span class="nx">IDENTIFIER</span><span class="p">.</span><span class="nx">test</span><span class="p">(</span><span class="nx">code</span><span class="p">)</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">o</span><span class="p">.</span><span class="nx">scope</span><span class="p">.</span><span class="nx">check</span> <span class="nx">code</span>
|
||||
<span class="p">[</span><span class="nx">cmp</span><span class="p">,</span> <span class="nx">cnj</span><span class="p">]</span> <span class="o">=</span> <span class="k">if</span> <span class="nx">@negated</span> <span class="k">then</span> <span class="p">[</span><span class="s">'==='</span><span class="p">,</span> <span class="s">'||'</span><span class="p">]</span> <span class="k">else</span> <span class="p">[</span><span class="s">'!=='</span><span class="p">,</span> <span class="s">'&&'</span><span class="p">]</span>
|
||||
<span class="nv">code = </span><span class="s">"typeof </span><span class="si">#{</span><span class="nx">code</span><span class="si">}</span><span class="s"> </span><span class="si">#{</span><span class="nx">cmp</span><span class="si">}</span><span class="s"> \"undefined\" </span><span class="si">#{</span><span class="nx">cnj</span><span class="si">}</span><span class="s"> </span><span class="si">#{</span><span class="nx">code</span><span class="si">}</span><span class="s"> </span><span class="si">#{</span><span class="nx">cmp</span><span class="si">}</span><span class="s"> null"</span>
|
||||
<span class="k">else</span></pre></div> </td> </tr> <tr id="section-146"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-146">¶</a> </div> <p>do not use strict equality here; it will break existing code</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">code = </span><span class="s">"</span><span class="si">#{</span><span class="nx">code</span><span class="si">}</span><span class="s"> </span><span class="si">#{</span><span class="k">if</span> <span class="nx">@negated</span> <span class="k">then</span> <span class="s">'=='</span> <span class="k">else</span> <span class="s">'!='</span><span class="si">}</span><span class="s"> null"</span>
|
||||
<span class="p">[</span><span class="nx">@makeCode</span><span class="p">(</span><span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o"><=</span> <span class="nx">LEVEL_COND</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s">"(</span><span class="si">#{</span><span class="nx">code</span><span class="si">}</span><span class="s">)"</span><span class="p">)]</span></pre></div> </td> </tr> <tr id="section-147"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-147">¶</a> </div> <h3>Parens</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-148"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-148">¶</a> </div> <p>An extra set of parentheses, specified explicitly in the source. At one time
|
||||
<span class="k">else</span></pre></div> </td> </tr> <tr id="section-145"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-145">¶</a> </div> <p>do not use strict equality here; it will break existing code</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">code = </span><span class="s">"</span><span class="si">#{</span><span class="nx">code</span><span class="si">}</span><span class="s"> </span><span class="si">#{</span><span class="k">if</span> <span class="nx">@negated</span> <span class="k">then</span> <span class="s">'=='</span> <span class="k">else</span> <span class="s">'!='</span><span class="si">}</span><span class="s"> null"</span>
|
||||
<span class="p">[</span><span class="nx">@makeCode</span><span class="p">(</span><span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o"><=</span> <span class="nx">LEVEL_COND</span> <span class="k">then</span> <span class="nx">code</span> <span class="k">else</span> <span class="s">"(</span><span class="si">#{</span><span class="nx">code</span><span class="si">}</span><span class="s">)"</span><span class="p">)]</span></pre></div> </td> </tr> <tr id="section-146"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-146">¶</a> </div> <h3>Parens</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-147"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-147">¶</a> </div> <p>An extra set of parentheses, specified explicitly in the source. At one time
|
||||
we tried to clean up the results by detecting and removing redundant
|
||||
parentheses, but no longer -- you can put in as many as you please.</p>
|
||||
|
||||
@@ -1437,7 +1429,7 @@ parentheses, but no longer -- you can put in as many as you please.</p>
|
||||
<span class="nv">fragments = </span><span class="nx">expr</span><span class="p">.</span><span class="nx">compileToFragments</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_PAREN</span>
|
||||
<span class="nv">bare = </span><span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o"><</span> <span class="nx">LEVEL_OP</span> <span class="o">and</span> <span class="p">(</span><span class="nx">expr</span> <span class="k">instanceof</span> <span class="nx">Op</span> <span class="o">or</span> <span class="nx">expr</span> <span class="k">instanceof</span> <span class="nx">Call</span> <span class="o">or</span>
|
||||
<span class="p">(</span><span class="nx">expr</span> <span class="k">instanceof</span> <span class="nx">For</span> <span class="o">and</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">returns</span><span class="p">))</span>
|
||||
<span class="k">if</span> <span class="nx">bare</span> <span class="k">then</span> <span class="nx">fragments</span> <span class="k">else</span> <span class="nx">@wrapInBraces</span> <span class="nx">fragments</span></pre></div> </td> </tr> <tr id="section-149"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-149">¶</a> </div> <h3>For</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-150"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-150">¶</a> </div> <p>CoffeeScript's replacement for the <em>for</em> loop is our array and object
|
||||
<span class="k">if</span> <span class="nx">bare</span> <span class="k">then</span> <span class="nx">fragments</span> <span class="k">else</span> <span class="nx">@wrapInBraces</span> <span class="nx">fragments</span></pre></div> </td> </tr> <tr id="section-148"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-148">¶</a> </div> <h3>For</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-149"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-149">¶</a> </div> <p>CoffeeScript's replacement for the <em>for</em> loop is our array and object
|
||||
comprehensions, that compile into <em>for</em> loops here. They also act as an
|
||||
expression, able to return the result of each filtered iteration.</p>
|
||||
|
||||
@@ -1457,7 +1449,7 @@ you can map and filter in a single pass.</p> </td> <td c
|
||||
<span class="k">throw</span> <span class="nx">SyntaxError</span> <span class="s">'cannot pattern match over range loops'</span> <span class="k">if</span> <span class="nx">@range</span> <span class="o">and</span> <span class="nx">@pattern</span>
|
||||
<span class="vi">@returns = </span><span class="kc">false</span>
|
||||
|
||||
<span class="nv">children: </span><span class="p">[</span><span class="s">'body'</span><span class="p">,</span> <span class="s">'source'</span><span class="p">,</span> <span class="s">'guard'</span><span class="p">,</span> <span class="s">'step'</span><span class="p">]</span></pre></div> </td> </tr> <tr id="section-151"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-151">¶</a> </div> <p>Welcome to the hairiest method in all of CoffeeScript. Handles the inner
|
||||
<span class="nv">children: </span><span class="p">[</span><span class="s">'body'</span><span class="p">,</span> <span class="s">'source'</span><span class="p">,</span> <span class="s">'guard'</span><span class="p">,</span> <span class="s">'step'</span><span class="p">]</span></pre></div> </td> </tr> <tr id="section-150"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-150">¶</a> </div> <p>Welcome to the hairiest method in all of CoffeeScript. Handles the inner
|
||||
loop, filtering, stepping, and result saving for array, object, and range
|
||||
comprehensions. Some of the generated code can be shared in common, and
|
||||
some cannot.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileNode: </span><span class="nf">(o) -></span>
|
||||
@@ -1551,7 +1543,7 @@ some cannot.</p> </td> <td class="code"> <
|
||||
<span class="p">[</span><span class="nx">val</span><span class="p">.</span><span class="nx">base</span><span class="p">,</span> <span class="nx">base</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="nx">base</span><span class="p">,</span> <span class="nx">val</span><span class="p">]</span>
|
||||
<span class="nx">body</span><span class="p">.</span><span class="nx">expressions</span><span class="p">[</span><span class="nx">idx</span><span class="p">]</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Call</span> <span class="nx">base</span><span class="p">,</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">args</span>
|
||||
<span class="nv">defs = </span><span class="nx">defs</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="nx">@tab</span><span class="p">),</span> <span class="p">(</span><span class="k">new</span> <span class="nx">Assign</span><span class="p">(</span><span class="nx">ref</span><span class="p">,</span> <span class="nx">fn</span><span class="p">).</span><span class="nx">compileToFragments</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_TOP</span><span class="p">)),</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="s">';\n'</span><span class="p">)</span>
|
||||
<span class="nx">defs</span></pre></div> </td> </tr> <tr id="section-152"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-152">¶</a> </div> <h3>Switch</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-153"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-153">¶</a> </div> <p>A JavaScript <em>switch</em> statement. Converts into a returnable expression on-demand.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.Switch = </span><span class="k">class</span> <span class="nx">Switch</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="nx">defs</span></pre></div> </td> </tr> <tr id="section-151"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-151">¶</a> </div> <h3>Switch</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-152"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-152">¶</a> </div> <p>A JavaScript <em>switch</em> statement. Converts into a returnable expression on-demand.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">exports.Switch = </span><span class="k">class</span> <span class="nx">Switch</span> <span class="k">extends</span> <span class="nx">Base</span>
|
||||
<span class="nv">constructor: </span><span class="nf">(@subject, @cases, @otherwise) -></span>
|
||||
|
||||
<span class="nv">children: </span><span class="p">[</span><span class="s">'subject'</span><span class="p">,</span> <span class="s">'cases'</span><span class="p">,</span> <span class="s">'otherwise'</span><span class="p">]</span>
|
||||
@@ -1587,7 +1579,7 @@ some cannot.</p> </td> <td class="code"> <
|
||||
<span class="k">if</span> <span class="nx">@otherwise</span> <span class="o">and</span> <span class="nx">@otherwise</span><span class="p">.</span><span class="nx">expressions</span><span class="p">.</span><span class="nx">length</span>
|
||||
<span class="nx">fragments</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="nx">idt1</span> <span class="o">+</span> <span class="s">"default:\n"</span><span class="p">),</span> <span class="p">(</span><span class="nx">@otherwise</span><span class="p">.</span><span class="nx">compileToFragments</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_TOP</span><span class="p">)...,</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="s">"\n"</span><span class="p">)</span>
|
||||
<span class="nx">fragments</span><span class="p">.</span><span class="nx">push</span> <span class="nx">@makeCode</span> <span class="nx">@tab</span> <span class="o">+</span> <span class="s">'}'</span>
|
||||
<span class="nx">fragments</span></pre></div> </td> </tr> <tr id="section-154"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-154">¶</a> </div> <h3>If</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-155"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-155">¶</a> </div> <p><em>If/else</em> statements. Acts as an expression by pushing down requested returns
|
||||
<span class="nx">fragments</span></pre></div> </td> </tr> <tr id="section-153"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-153">¶</a> </div> <h3>If</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-154"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-154">¶</a> </div> <p><em>If/else</em> statements. Acts as an expression by pushing down requested returns
|
||||
to the last line of each clause.</p>
|
||||
|
||||
<p>Single-expression <strong>Ifs</strong> are compiled into conditional operators if possible,
|
||||
@@ -1601,13 +1593,13 @@ because ternaries are already proper expressions, and don't need conversion.</p>
|
||||
<span class="nv">children: </span><span class="p">[</span><span class="s">'condition'</span><span class="p">,</span> <span class="s">'body'</span><span class="p">,</span> <span class="s">'elseBody'</span><span class="p">]</span>
|
||||
|
||||
<span class="nv">bodyNode: </span> <span class="nf">-></span> <span class="nx">@body</span><span class="o">?</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">()</span>
|
||||
<span class="nv">elseBodyNode: </span><span class="nf">-></span> <span class="nx">@elseBody</span><span class="o">?</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">()</span></pre></div> </td> </tr> <tr id="section-156"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-156">¶</a> </div> <p>Rewrite a chain of <strong>Ifs</strong> to add a default case as the final <em>else</em>.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">addElse: </span><span class="nf">(elseBody) -></span>
|
||||
<span class="nv">elseBodyNode: </span><span class="nf">-></span> <span class="nx">@elseBody</span><span class="o">?</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">()</span></pre></div> </td> </tr> <tr id="section-155"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-155">¶</a> </div> <p>Rewrite a chain of <strong>Ifs</strong> to add a default case as the final <em>else</em>.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">addElse: </span><span class="nf">(elseBody) -></span>
|
||||
<span class="k">if</span> <span class="nx">@isChain</span>
|
||||
<span class="nx">@elseBodyNode</span><span class="p">().</span><span class="nx">addElse</span> <span class="nx">elseBody</span>
|
||||
<span class="k">else</span>
|
||||
<span class="vi">@isChain = </span><span class="nx">elseBody</span> <span class="k">instanceof</span> <span class="nx">If</span>
|
||||
<span class="vi">@elseBody = </span><span class="nx">@ensureBlock</span> <span class="nx">elseBody</span>
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-157"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-157">¶</a> </div> <p>The <strong>If</strong> only compiles into a statement if either of its bodies needs
|
||||
<span class="k">this</span></pre></div> </td> </tr> <tr id="section-156"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-156">¶</a> </div> <p>The <strong>If</strong> only compiles into a statement if either of its bodies needs
|
||||
to be a statement. Otherwise a conditional operator is safe.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">isStatement: </span><span class="nf">(o) -></span>
|
||||
<span class="nx">o</span><span class="o">?</span><span class="p">.</span><span class="nx">level</span> <span class="o">is</span> <span class="nx">LEVEL_TOP</span> <span class="o">or</span>
|
||||
<span class="nx">@bodyNode</span><span class="p">().</span><span class="nx">isStatement</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span> <span class="o">or</span> <span class="nx">@elseBodyNode</span><span class="p">()</span><span class="o">?</span><span class="p">.</span><span class="nx">isStatement</span><span class="p">(</span><span class="nx">o</span><span class="p">)</span>
|
||||
@@ -1624,7 +1616,7 @@ to be a statement. Otherwise a conditional operator is safe.</p> </t
|
||||
<span class="k">this</span>
|
||||
|
||||
<span class="nv">ensureBlock: </span><span class="nf">(node) -></span>
|
||||
<span class="k">if</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Block</span> <span class="k">then</span> <span class="nx">node</span> <span class="k">else</span> <span class="k">new</span> <span class="nx">Block</span> <span class="p">[</span><span class="nx">node</span><span class="p">]</span></pre></div> </td> </tr> <tr id="section-158"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-158">¶</a> </div> <p>Compile the <code>If</code> as a regular <em>if-else</em> statement. Flattened chains
|
||||
<span class="k">if</span> <span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Block</span> <span class="k">then</span> <span class="nx">node</span> <span class="k">else</span> <span class="k">new</span> <span class="nx">Block</span> <span class="p">[</span><span class="nx">node</span><span class="p">]</span></pre></div> </td> </tr> <tr id="section-157"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-157">¶</a> </div> <p>Compile the <code>If</code> as a regular <em>if-else</em> statement. Flattened chains
|
||||
force inner <em>else</em> bodies into statement form.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileStatement: </span><span class="nf">(o) -></span>
|
||||
<span class="nv">child = </span><span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s">'chainChild'</span>
|
||||
<span class="nv">exeq = </span><span class="nx">del</span> <span class="nx">o</span><span class="p">,</span> <span class="s">'isExistentialEquals'</span>
|
||||
@@ -1644,7 +1636,7 @@ force inner <em>else</em> bodies into statement form.</p> </td>
|
||||
<span class="nv">answer = </span><span class="nx">answer</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">@elseBody</span><span class="p">.</span><span class="nx">unwrap</span><span class="p">().</span><span class="nx">compileToFragments</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_TOP</span>
|
||||
<span class="k">else</span>
|
||||
<span class="nv">answer = </span><span class="nx">answer</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="s">"{\n"</span><span class="p">),</span> <span class="nx">@elseBody</span><span class="p">.</span><span class="nx">compileToFragments</span><span class="p">(</span><span class="nx">merge</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="p">{</span><span class="nx">indent</span><span class="p">}),</span> <span class="nx">LEVEL_TOP</span><span class="p">),</span> <span class="nx">@makeCode</span><span class="p">(</span><span class="s">"\n</span><span class="si">#{</span><span class="nx">@tab</span><span class="si">}</span><span class="s">}"</span><span class="p">)</span>
|
||||
<span class="nx">answer</span></pre></div> </td> </tr> <tr id="section-159"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-159">¶</a> </div> <p>Compile the <code>If</code> as a conditional operator.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileExpression: </span><span class="nf">(o) -></span>
|
||||
<span class="nx">answer</span></pre></div> </td> </tr> <tr id="section-158"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-158">¶</a> </div> <p>Compile the <code>If</code> as a conditional operator.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">compileExpression: </span><span class="nf">(o) -></span>
|
||||
<span class="nv">cond = </span><span class="nx">@condition</span><span class="p">.</span><span class="nx">compileToFragments</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_COND</span>
|
||||
<span class="nv">body = </span><span class="nx">@bodyNode</span><span class="p">().</span><span class="nx">compileToFragments</span> <span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span>
|
||||
<span class="nv">alt = </span><span class="k">if</span> <span class="nx">@elseBodyNode</span><span class="p">()</span> <span class="k">then</span> <span class="nx">@elseBodyNode</span><span class="p">().</span><span class="nx">compileToFragments</span><span class="p">(</span><span class="nx">o</span><span class="p">,</span> <span class="nx">LEVEL_LIST</span><span class="p">)</span> <span class="k">else</span> <span class="p">[</span><span class="nx">@makeCode</span><span class="p">(</span><span class="s">'void 0'</span><span class="p">)]</span>
|
||||
@@ -1652,10 +1644,10 @@ force inner <em>else</em> bodies into statement form.</p> </td>
|
||||
<span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">level</span> <span class="o">>=</span> <span class="nx">LEVEL_COND</span> <span class="k">then</span> <span class="nx">@wrapInBraces</span> <span class="nx">fragments</span> <span class="k">else</span> <span class="nx">fragments</span>
|
||||
|
||||
<span class="nv">unfoldSoak: </span><span class="nf">-></span>
|
||||
<span class="nx">@soak</span> <span class="o">and</span> <span class="k">this</span></pre></div> </td> </tr> <tr id="section-160"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-160">¶</a> </div> <h2>Faux-Nodes</h2>
|
||||
<span class="nx">@soak</span> <span class="o">and</span> <span class="k">this</span></pre></div> </td> </tr> <tr id="section-159"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-159">¶</a> </div> <h2>Faux-Nodes</h2>
|
||||
|
||||
<p>Faux-nodes are never created by the grammar, but are used during code
|
||||
generation to generate other combinations of nodes.</p> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-161"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-161">¶</a> </div> <h3>Closure</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-162"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-162">¶</a> </div> <p>A faux-node used to wrap an expressions body in a closure.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">Closure =</span></pre></div> </td> </tr> <tr id="section-163"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-163">¶</a> </div> <p>Wrap the expressions body, unless it contains a pure statement,
|
||||
generation to generate other combinations of nodes.</p> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-160"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-160">¶</a> </div> <h3>Closure</h3> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-161"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-161">¶</a> </div> <p>A faux-node used to wrap an expressions body in a closure.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">Closure =</span></pre></div> </td> </tr> <tr id="section-162"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-162">¶</a> </div> <p>Wrap the expressions body, unless it contains a pure statement,
|
||||
in which case, no dice. If the body mentions <code>this</code> or <code>arguments</code>,
|
||||
then make sure that the closure wrapper preserves the original values.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">wrap: </span><span class="nf">(expressions, statement, noReturn) -></span>
|
||||
<span class="k">return</span> <span class="nx">expressions</span> <span class="k">if</span> <span class="nx">expressions</span><span class="p">.</span><span class="nx">jumps</span><span class="p">()</span>
|
||||
@@ -1678,23 +1670,23 @@ then make sure that the closure wrapper preserves the original values.</p>
|
||||
<span class="nv">literalThis: </span><span class="nf">(node) -></span>
|
||||
<span class="p">(</span><span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Literal</span> <span class="o">and</span> <span class="nx">node</span><span class="p">.</span><span class="nx">value</span> <span class="o">is</span> <span class="s">'this'</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">node</span><span class="p">.</span><span class="nx">asKey</span><span class="p">)</span> <span class="o">or</span>
|
||||
<span class="p">(</span><span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Code</span> <span class="o">and</span> <span class="nx">node</span><span class="p">.</span><span class="nx">bound</span><span class="p">)</span> <span class="o">or</span>
|
||||
<span class="p">(</span><span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Call</span> <span class="o">and</span> <span class="nx">node</span><span class="p">.</span><span class="nx">isSuper</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-164"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-164">¶</a> </div> <p>Unfold a node's child if soak, then tuck the node under created <code>If</code></p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">unfoldSoak = </span><span class="nf">(o, parent, name) -></span>
|
||||
<span class="p">(</span><span class="nx">node</span> <span class="k">instanceof</span> <span class="nx">Call</span> <span class="o">and</span> <span class="nx">node</span><span class="p">.</span><span class="nx">isSuper</span><span class="p">)</span></pre></div> </td> </tr> <tr id="section-163"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-163">¶</a> </div> <p>Unfold a node's child if soak, then tuck the node under created <code>If</code></p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">unfoldSoak = </span><span class="nf">(o, parent, name) -></span>
|
||||
<span class="k">return</span> <span class="k">unless</span> <span class="nv">ifn = </span><span class="nx">parent</span><span class="p">[</span><span class="nx">name</span><span class="p">].</span><span class="nx">unfoldSoak</span> <span class="nx">o</span>
|
||||
<span class="nx">parent</span><span class="p">[</span><span class="nx">name</span><span class="p">]</span> <span class="o">=</span> <span class="nx">ifn</span><span class="p">.</span><span class="nx">body</span>
|
||||
<span class="nv">ifn.body = </span><span class="k">new</span> <span class="nx">Value</span> <span class="nx">parent</span>
|
||||
<span class="nx">ifn</span></pre></div> </td> </tr> <tr id="section-165"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-165">¶</a> </div> <h2>Constants</h2> </td> <td class="code"> <div class="highlight"><pre><span class="nv">UTILITIES =</span></pre></div> </td> </tr> <tr id="section-166"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-166">¶</a> </div> <p>Correctly set up a prototype chain for inheritance, including a reference
|
||||
<span class="nx">ifn</span></pre></div> </td> </tr> <tr id="section-164"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-164">¶</a> </div> <h2>Constants</h2> </td> <td class="code"> <div class="highlight"><pre><span class="nv">UTILITIES =</span></pre></div> </td> </tr> <tr id="section-165"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-165">¶</a> </div> <p>Correctly set up a prototype chain for inheritance, including a reference
|
||||
to the superclass for <code>super()</code> calls, and copies of any static properties.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="k">extends</span><span class="o">:</span> <span class="nf">-></span> <span class="s">"""</span>
|
||||
<span class="s"> function(child, parent) { for (var key in parent) { if (</span><span class="si">#{</span><span class="nx">utility</span> <span class="s">'hasProp'</span><span class="si">}</span><span class="s">.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }</span>
|
||||
<span class="s"> """</span></pre></div> </td> </tr> <tr id="section-167"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-167">¶</a> </div> <p>Discover if an item is in an array.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">indexOf: </span><span class="nf">-></span> <span class="s">"""</span>
|
||||
<span class="s"> """</span></pre></div> </td> </tr> <tr id="section-166"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-166">¶</a> </div> <p>Discover if an item is in an array.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">indexOf: </span><span class="nf">-></span> <span class="s">"""</span>
|
||||
<span class="s"> [].indexOf || function(item) { for (var i = 0, l = this.length; i < l; i++) { if (i in this && this[i] === item) return i; } return -1; }</span>
|
||||
<span class="s"> """</span></pre></div> </td> </tr> <tr id="section-168"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-168">¶</a> </div> <p>Shortcuts to speed up the lookup time for native functions.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">hasProp: </span><span class="nf">-></span> <span class="s">'{}.hasOwnProperty'</span>
|
||||
<span class="nv">slice : </span><span class="nf">-></span> <span class="s">'[].slice'</span></pre></div> </td> </tr> <tr id="section-169"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-169">¶</a> </div> <p>Levels indicate a node's position in the AST. Useful for knowing if
|
||||
<span class="s"> """</span></pre></div> </td> </tr> <tr id="section-167"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-167">¶</a> </div> <p>Shortcuts to speed up the lookup time for native functions.</p> </td> <td class="code"> <div class="highlight"><pre> <span class="nv">hasProp: </span><span class="nf">-></span> <span class="s">'{}.hasOwnProperty'</span>
|
||||
<span class="nv">slice : </span><span class="nf">-></span> <span class="s">'[].slice'</span></pre></div> </td> </tr> <tr id="section-168"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-168">¶</a> </div> <p>Levels indicate a node's position in the AST. Useful for knowing if
|
||||
parens are necessary or superfluous.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">LEVEL_TOP = </span><span class="mi">1</span> <span class="c1"># ...;</span>
|
||||
<span class="nv">LEVEL_PAREN = </span><span class="mi">2</span> <span class="c1"># (...)</span>
|
||||
<span class="nv">LEVEL_LIST = </span><span class="mi">3</span> <span class="c1"># [...]</span>
|
||||
<span class="nv">LEVEL_COND = </span><span class="mi">4</span> <span class="c1"># ... ? x : y</span>
|
||||
<span class="nv">LEVEL_OP = </span><span class="mi">5</span> <span class="c1"># !...</span>
|
||||
<span class="nv">LEVEL_ACCESS = </span><span class="mi">6</span> <span class="c1"># ...[0]</span></pre></div> </td> </tr> <tr id="section-170"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-170">¶</a> </div> <p>Tabs are two spaces for pretty printing.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">TAB = </span><span class="s">' '</span>
|
||||
<span class="nv">LEVEL_ACCESS = </span><span class="mi">6</span> <span class="c1"># ...[0]</span></pre></div> </td> </tr> <tr id="section-169"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-169">¶</a> </div> <p>Tabs are two spaces for pretty printing.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">TAB = </span><span class="s">' '</span>
|
||||
|
||||
<span class="nv">IDENTIFIER_STR = </span><span class="s">"[$A-Za-z_\\x7f-\\uffff][$\\w\\x7f-\\uffff]*"</span>
|
||||
<span class="nv">IDENTIFIER = </span><span class="sr">/// ^ </span><span class="si">#{</span><span class="nx">IDENTIFIER_STR</span><span class="si">}</span><span class="sr"> $ ///</span>
|
||||
@@ -1713,7 +1705,7 @@ parens are necessary or superfluous.</p> </td> <td class
|
||||
<span class="sr"> |</span>
|
||||
<span class="sr"> (</span><span class="si">#{</span><span class="nx">IDENTIFIER_STR</span><span class="si">}</span><span class="sr">)</span>
|
||||
<span class="sr"> $</span>
|
||||
<span class="sr">///</span></pre></div> </td> </tr> <tr id="section-171"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-171">¶</a> </div> <p>Is a literal value a string?</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">IS_STRING = </span><span class="sr">/^['"]/</span></pre></div> </td> </tr> <tr id="section-172"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-172">¶</a> </div> <h2>Utility Functions</h2> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-173"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-173">¶</a> </div> <p>Helper for ensuring that utility functions are assigned at the top level.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">utility = </span><span class="nf">(name) -></span>
|
||||
<span class="sr">///</span></pre></div> </td> </tr> <tr id="section-170"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-170">¶</a> </div> <p>Is a literal value a string?</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">IS_STRING = </span><span class="sr">/^['"]/</span></pre></div> </td> </tr> <tr id="section-171"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-171">¶</a> </div> <h2>Utility Functions</h2> </td> <td class="code"> <div class="highlight"><pre></pre></div> </td> </tr> <tr id="section-172"> <td class="docs"> <div class="pilwrap"> <a class="pilcrow" href="#section-172">¶</a> </div> <p>Helper for ensuring that utility functions are assigned at the top level.</p> </td> <td class="code"> <div class="highlight"><pre><span class="nv">utility = </span><span class="nf">(name) -></span>
|
||||
<span class="nv">ref = </span><span class="s">"__</span><span class="si">#{</span><span class="nx">name</span><span class="si">}</span><span class="s">"</span>
|
||||
<span class="nx">Scope</span><span class="p">.</span><span class="nx">root</span><span class="p">.</span><span class="nx">assign</span> <span class="nx">ref</span><span class="p">,</span> <span class="nx">UTILITIES</span><span class="p">[</span><span class="nx">name</span><span class="p">]()</span>
|
||||
<span class="nx">ref</span>
|
||||
|
||||
Reference in New Issue
Block a user