CoffeeScript 1.1.2

Check for existence of this.context. Avoid build error.

.npmignore

@@ -5,7 +5,7 @@
 Cakefile
 documentation/
 examples/
-extras/
+extras/coffee-script.js
 raw/
 src/
 test/

Cakefile

@@ -16,7 +16,7 @@ header = """
    * CoffeeScript Compiler v#{CoffeeScript.VERSION}
    * http://coffeescript.org
    *
-   * Copyright 2010, Jeremy Ashkenas
+   * Copyright 2011, Jeremy Ashkenas
    * Released under the MIT License
    */
 """
@@ -28,10 +28,12 @@ sources = [
 ]
 
 # Run a CoffeeScript through our node/coffee interpreter.
-run = (args) ->
+run = (args, cb) ->
   proc =         spawn 'bin/coffee', args
   proc.stderr.on 'data', (buffer) -> console.log buffer.toString()
-  proc.on        'exit', (status) -> process.exit(1) if status != 0
+  proc.on        'exit', (status) ->
+    process.exit(1) if status != 0
+    cb() if typeof cb is 'function'
 
 # Log a message with a color.
 log = (message, color, explanation) ->
@@ -50,26 +52,25 @@ task 'install', 'install CoffeeScript into /usr/local (or --prefix)', (options)
   exec([
     "mkdir -p #{lib} #{bin}"
     "cp -rf bin lib LICENSE README package.json src #{lib}"
-    "ln -sf #{lib}/bin/coffee #{bin}/coffee"
-    "ln -sf #{lib}/bin/cake #{bin}/cake"
+    "ln -sfn #{lib}/bin/coffee #{bin}/coffee"
+    "ln -sfn #{lib}/bin/cake #{bin}/cake"
     "mkdir -p ~/.node_libraries"
-    "ln -sf #{lib}/lib #{node}"
+    "ln -sfn #{lib}/lib #{node}"
   ].join(' && '), (err, stdout, stderr) ->
     if err then console.log stderr.trim() else log 'done', green
   )
 
 
-task 'build', 'build the CoffeeScript language from source', ->
+task 'build', 'build the CoffeeScript language from source', build = (cb) ->
   files = fs.readdirSync 'src'
   files = ('src/' + file for file in files when file.match(/\.coffee$/))
-  run ['-c', '-o', 'lib'].concat(files)
+  run ['-c', '-o', 'lib'].concat(files), cb
 
 
 task 'build:full', 'rebuild the source twice, and run the tests', ->
-  exec 'bin/cake build && bin/cake build && bin/cake test', (err, stdout, stderr) ->
-    console.log stdout.trim() if stdout
-    console.log stderr.trim() if stderr
-    throw err    if err
+  build ->
+    build ->
+      process.exit 1 unless runTests CoffeeScript
 
 
 task 'build:parser', 'rebuild the Jison parser (run build first)', ->
@@ -94,16 +95,18 @@ task 'build:browser', 'rebuild the merged script for inclusion in the browser',
         #{fs.readFileSync "lib/#{name}.js"}
       };
     """
-  {parser, uglify} = require 'uglify-js'
-  ast = parser.parse """
+  code = """
     this.CoffeeScript = function() {
       function require(path){ return require[path]; }
       #{code}
       return require['./coffee-script']
     }()
   """
-  code = uglify.gen_code uglify.ast_squeeze uglify.ast_mangle ast, extra: yes
+  unless process.env.MINIFY is 'false'
+    {parser, uglify} = require 'uglify-js'
+    code = uglify.gen_code uglify.ast_squeeze uglify.ast_mangle parser.parse code
   fs.writeFileSync 'extras/coffee-script.js', header + '\n' + code
+  console.log "built ... running browser tests:"
   invoke 'test:browser'
 
 
@@ -150,6 +153,9 @@ runTests = (CoffeeScript) ->
   passedTests = 0
   failures    = []
 
+  # Make "global" reference available to tests
+  global.global = global
+
   # Mix in the assert module globally, to make it available for tests.
   addGlobal = (name, func) ->
     global[name] = ->
@@ -165,11 +171,12 @@ runTests = (CoffeeScript) ->
   # Our test helper function for delimiting different test cases.
   global.test = (description, fn) ->
     try
-      fn()
+      fn.test = {description, currentFile}
+      fn.call(fn)
     catch e
       e.description = description if description?
       e.source      = fn.toString() if fn.toString?
-      failures.push file: currentFile, error: e
+      failures.push filename: currentFile, error: e
 
   # A recursive functional equivalence helper; uses egal for testing equivalence.
   # See http://wiki.ecmascript.org/doku.php?id=harmony:egal
@@ -195,26 +202,28 @@ runTests = (CoffeeScript) ->
     return log(message, green) unless failures.length
     log "failed #{failures.length} and #{message}", red
     for fail in failures
-      {error, file}      = fail
-      jsFile             = file.replace(/\.coffee$/,'.js')
+      {error, filename}  = fail
+      jsFilename         = filename.replace(/\.coffee$/,'.js')
       match              = error.stack?.match(new RegExp(fail.file+":(\\d+):(\\d+)"))
+      match              = error.stack?.match(/on line (\d+):/) unless match
       [match, line, col] = match if match
-      log "\n  #{error.toString()}", red
+      console.log ''
       log "  #{error.description}", red if error.description
-      log "  #{jsFile}: line #{line or 'unknown'}, column #{col or 'unknown'}", red
+      log "  #{error.stack}", red
+      log "  #{jsFilename}: line #{line ? 'unknown'}, column #{col ? 'unknown'}", red
       console.log "  #{error.source}" if error.source
+    return
 
   # Run every test in the `test` folder, recording failures.
-  fs.readdir 'test', (err, files) ->
-    files.forEach (file) ->
-      return unless file.match(/\.coffee$/i)
-      fileName = path.join 'test', file
-      fs.readFile fileName, (err, code) ->
-        currentFile = fileName
-        try
-          CoffeeScript.run code.toString(), {fileName}
-        catch e
-          failures.push file: currentFile, error: e
+  files = fs.readdirSync 'test'
+  for file in files when file.match /\.coffee$/i
+    currentFile = filename = path.join 'test', file
+    code = fs.readFileSync filename
+    try
+      CoffeeScript.run code.toString(), {filename}
+    catch error
+      failures.push {filename, error}
+  return !failures.length
 
 
 task 'test', 'run the CoffeeScript language test suite', ->

LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Jeremy Ashkenas
+Copyright (c) 2011 Jeremy Ashkenas
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

README

@@ -26,7 +26,8 @@
   sudo bin/cake install
 
   Or, if you have the Node Package Manager installed:
-  npm install coffee-script
+  npm install -g coffee-script
+  (Leave off the -g if you don't wish to install globally.)
 
   Compile a script:
   coffee /path/to/script.coffee

documentation/coffee/aliases.coffee

@@ -8,4 +8,4 @@ if car.speed < limit then accelerate()
 
 winner = yes if pick in [47, 92, 13]
 
-print inspect "My name is " + @name
+print inspect "My name is #{@name}"

documentation/coffee/block_comment.coffee

@@ -1,5 +1,5 @@
 ###
-CoffeeScript Compiler v1.0.0
+CoffeeScript Compiler v1.1.2
 Released under the MIT License
 ###
 

documentation/coffee/classes.coffee

@@ -2,7 +2,7 @@ class Animal
   constructor: (@name) ->
 
   move: (meters) ->
-    alert @name + " moved " + meters + "m."
+    alert @name + " moved #{meters}m."
 
 class Snake extends Animal
   move: ->

documentation/coffee/do.coffee

@@ -1,4 +1,4 @@
-for fileName in list
-  do (fileName) ->
-    fs.readFile fileName, (err, contents) ->
-      compile fileName, contents.toString()
+for filename in list
+  do (filename) ->
+    fs.readFile filename, (err, contents) ->
+      compile filename, contents.toString()

documentation/coffee/expressions_try.coffee

@@ -2,6 +2,6 @@ alert(
   try
     nonexistent / undefined
   catch error
-    "And the error is ... " + error
+    "And the error is ... #{error}"
 )
 

documentation/coffee/object_comprehensions.coffee

@@ -1,4 +1,4 @@
 yearsOld = max: 10, ida: 9, tim: 11
 
 ages = for child, age of yearsOld
-  child + " is " + age
+  "#{child} is #{age}"

documentation/coffee/while.coffee

@@ -6,5 +6,5 @@ if this.studyingEconomics
 # Nursery Rhyme
 num = 6
 lyrics = while num -= 1
-  num + " little monkeys, jumping on the bed.
+  "#{num} little monkeys, jumping on the bed.
     One fell out and bumped his head."

documentation/css/docs.css

@@ -45,6 +45,7 @@ table {
   }
     td {
       padding: 9px 15px 9px 0;
+      vertical-align: top;
     }
 table.definitions {
   width: auto;
@@ -84,6 +85,10 @@ code, pre, tt, textarea {
   font-weight: normal;
   color: black;
 }
+  .timestamp small {
+    font-size: 11px;
+    text-transform: uppercase;
+  }
 div.code {
   position: relative;
   background: #fff;

documentation/docs/browser.html

@@ -2,21 +2,32 @@
 <span class="nv">CoffeeScript.require = </span><span class="nx">require</span></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-2">&#182;</a>               </div>               <p>Use standard JavaScript <code>eval</code> to eval code.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CoffeeScript.eval = </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
   <span class="nb">eval</span> <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">options</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</a>               </div>               <p>Running code does not provide access to this scope.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CoffeeScript.run = </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nv">options = </span><span class="p">{})</span> <span class="o">-&gt;</span>
   <span class="nv">options.bare = </span><span class="kc">on</span>
-  <span class="nb">Function</span><span class="p">(</span><span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">)()</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>If we're not in a browser environment, we're finished with the public API.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">return</span> <span class="nx">unless</span> <span class="nb">window</span><span class="o">?</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-5">&#182;</a>               </div>               <p>Load a remote script from the current domain via XHR.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CoffeeScript.load = </span><span class="p">(</span><span class="nx">url</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nb">Function</span><span class="p">(</span><span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">)()</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>If we're not in a browser environment, we're finished with the public API.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">return</span> <span class="nx">unless</span> <span class="nb">window</span><span class="o">?</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-5">&#182;</a>               </div>               <p>Load a remote script from the current domain via XHR.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CoffeeScript.load = </span><span class="p">(</span><span class="nx">url</span><span class="p">,</span> <span class="nx">callback</span><span class="p">)</span> <span class="o">-&gt;</span>
   <span class="nv">xhr = </span><span class="k">new</span> <span class="p">(</span><span class="nb">window</span><span class="p">.</span><span class="nx">ActiveXObject</span> <span class="o">or</span> <span class="nx">XMLHttpRequest</span><span class="p">)(</span><span class="s1">&#39;Microsoft.XMLHTTP&#39;</span><span class="p">)</span>
   <span class="nx">xhr</span><span class="p">.</span><span class="nx">open</span> <span class="s1">&#39;GET&#39;</span><span class="p">,</span> <span class="nx">url</span><span class="p">,</span> <span class="kc">true</span>
   <span class="nx">xhr</span><span class="p">.</span><span class="nx">overrideMimeType</span> <span class="s1">&#39;text/plain&#39;</span> <span class="k">if</span> <span class="s1">&#39;overrideMimeType&#39;</span> <span class="k">of</span> <span class="nx">xhr</span>
   <span class="nv">xhr.onreadystatechange = </span><span class="o">-&gt;</span>
-    <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">run</span> <span class="nx">xhr</span><span class="p">.</span><span class="nx">responseText</span><span class="p">,</span> <span class="nx">options</span> <span class="k">if</span> <span class="nx">xhr</span><span class="p">.</span><span class="nx">readyState</span> <span class="o">is</span> <span class="mi">4</span>
+    <span class="k">if</span> <span class="nx">xhr</span><span class="p">.</span><span class="nx">readyState</span> <span class="o">is</span> <span class="mi">4</span>
+      <span class="k">if</span> <span class="nx">xhr</span><span class="p">.</span><span class="nx">status</span> <span class="k">in</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">200</span><span class="p">]</span>
+        <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">run</span> <span class="nx">xhr</span><span class="p">.</span><span class="nx">responseText</span>
+      <span class="k">else</span>
+        <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;Could not load #{url}&quot;</span>
+      <span class="nx">callback</span><span class="p">()</span> <span class="k">if</span> <span class="nx">callback</span>
   <span class="nx">xhr</span><span class="p">.</span><span class="nx">send</span> <span class="kc">null</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-6">&#182;</a>               </div>               <p>Activate CoffeeScript in the browser by having it compile and evaluate
 all script tags with a content-type of <code>text/coffeescript</code>.
 This happens on page load.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">runScripts = </span><span class="o">-&gt;</span>
-  <span class="k">for</span> <span class="nx">script</span> <span class="k">in</span> <span class="nb">document</span><span class="p">.</span><span class="nx">getElementsByTagName</span> <span class="s1">&#39;script&#39;</span>
-    <span class="k">if</span> <span class="nx">script</span><span class="p">.</span><span class="nx">type</span> <span class="o">is</span> <span class="s1">&#39;text/coffeescript&#39;</span>
+  <span class="nv">scripts = </span><span class="nb">document</span><span class="p">.</span><span class="nx">getElementsByTagName</span> <span class="s1">&#39;script&#39;</span>
+  <span class="nv">coffees = </span><span class="p">(</span><span class="nx">s</span> <span class="k">for</span> <span class="nx">s</span> <span class="k">in</span> <span class="nx">scripts</span> <span class="k">when</span> <span class="nx">s</span><span class="p">.</span><span class="nx">type</span> <span class="o">is</span> <span class="s1">&#39;text/coffeescript&#39;</span><span class="p">)</span>
+  <span class="nv">index = </span><span class="mi">0</span>
+  <span class="nv">length = </span><span class="nx">coffees</span><span class="p">.</span><span class="nx">length</span>
+  <span class="nx">do</span> <span class="nv">execute = </span><span class="o">-&gt;</span>
+    <span class="nv">script = </span><span class="nx">coffees</span><span class="p">[</span><span class="nx">index</span><span class="o">++</span><span class="p">]</span>
+    <span class="k">if</span> <span class="nx">script</span><span class="o">?</span><span class="p">.</span><span class="nx">type</span> <span class="o">is</span> <span class="s1">&#39;text/coffeescript&#39;</span>
       <span class="k">if</span> <span class="nx">script</span><span class="p">.</span><span class="nx">src</span>
-        <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">load</span> <span class="nx">script</span><span class="p">.</span><span class="nx">src</span>
+        <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">load</span> <span class="nx">script</span><span class="p">.</span><span class="nx">src</span><span class="p">,</span> <span class="nx">execute</span>
       <span class="k">else</span>
         <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">run</span> <span class="nx">script</span><span class="p">.</span><span class="nx">innerHTML</span>
+        <span class="nx">execute</span><span class="p">()</span>
   <span class="kc">null</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-7">&#182;</a>               </div>               <p>Listen for window load, both in browsers and in IE.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">if</span> <span class="nb">window</span><span class="p">.</span><span class="nx">addEventListener</span>
   <span class="nx">addEventListener</span> <span class="s1">&#39;DOMContentLoaded&#39;</span><span class="p">,</span> <span class="nx">runScripts</span><span class="p">,</span> <span class="kc">no</span>
 <span class="k">else</span>

documentation/docs/cake.html

@@ -25,7 +25,7 @@ If no tasks are passed, print the help screen.</p>             </td>
   <span class="nx">path</span><span class="p">.</span><span class="nx">exists</span> <span class="s1">&#39;Cakefile&#39;</span><span class="p">,</span> <span class="p">(</span><span class="nx">exists</span><span class="p">)</span> <span class="o">-&gt;</span>
     <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span><span class="p">(</span><span class="s2">&quot;Cakefile not found in #{process.cwd()}&quot;</span><span class="p">)</span> <span class="nx">unless</span> <span class="nx">exists</span>
     <span class="nv">args = </span><span class="nx">process</span><span class="p">.</span><span class="nx">argv</span><span class="p">.</span><span class="nx">slice</span> <span class="mi">2</span>
-    <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">run</span> <span class="nx">fs</span><span class="p">.</span><span class="nx">readFileSync</span><span class="p">(</span><span class="s1">&#39;Cakefile&#39;</span><span class="p">).</span><span class="nx">toString</span><span class="p">(),</span> <span class="nx">fileName</span><span class="o">:</span> <span class="s1">&#39;Cakefile&#39;</span>
+    <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">run</span> <span class="nx">fs</span><span class="p">.</span><span class="nx">readFileSync</span><span class="p">(</span><span class="s1">&#39;Cakefile&#39;</span><span class="p">).</span><span class="nx">toString</span><span class="p">(),</span> <span class="nx">filename</span><span class="o">:</span> <span class="s1">&#39;Cakefile&#39;</span>
     <span class="nv">oparse = </span><span class="k">new</span> <span class="nx">optparse</span><span class="p">.</span><span class="nx">OptionParser</span> <span class="nx">switches</span>
     <span class="k">return</span> <span class="nx">printTasks</span><span class="p">()</span> <span class="nx">unless</span> <span class="nx">args</span><span class="p">.</span><span class="nx">length</span>
     <span class="nv">options = </span><span class="nx">oparse</span><span class="p">.</span><span class="nx">parse</span><span class="p">(</span><span class="nx">args</span><span class="p">)</span>
@@ -36,7 +36,7 @@ If no tasks are passed, print the help screen.</p>             </td>
     <span class="nv">spaces = </span><span class="k">if</span> <span class="nx">spaces</span> <span class="o">&gt;</span> <span class="mi">0</span> <span class="k">then</span> <span class="nb">Array</span><span class="p">(</span><span class="nx">spaces</span> <span class="o">+</span> <span class="mi">1</span><span class="p">).</span><span class="nx">join</span><span class="p">(</span><span class="s1">&#39; &#39;</span><span class="p">)</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span>
     <span class="nv">desc   = </span><span class="k">if</span> <span class="nx">task</span><span class="p">.</span><span class="nx">description</span> <span class="k">then</span> <span class="s2">&quot;# #{task.description}&quot;</span> <span class="k">else</span> <span class="s1">&#39;&#39;</span>
     <span class="nx">console</span><span class="p">.</span><span class="nx">log</span> <span class="s2">&quot;cake #{name}#{spaces} #{desc}&quot;</span>
-  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span> <span class="nx">oparse</span><span class="p">.</span><span class="nx">help</span><span class="p">()</span> <span class="k">if</span> <span class="nx">switches</span><span class="p">.</span><span class="nx">length</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <p>Print an error and exit when attempting to all an undefined task.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">missingTask = </span><span class="p">(</span><span class="nx">task</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">console</span><span class="p">.</span><span class="nx">log</span> <span class="nx">oparse</span><span class="p">.</span><span class="nx">help</span><span class="p">()</span> <span class="k">if</span> <span class="nx">switches</span><span class="p">.</span><span class="nx">length</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <p>Print an error and exit when attempting to call an undefined task.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">missingTask = </span><span class="p">(</span><span class="nx">task</span><span class="p">)</span> <span class="o">-&gt;</span>
   <span class="nx">console</span><span class="p">.</span><span class="nx">log</span> <span class="s2">&quot;No such task: \&quot;#{task}\&quot;&quot;</span>
   <span class="nx">process</span><span class="p">.</span><span class="nx">exit</span> <span class="mi">1</span>
 

documentation/docs/coffee-script.html

@@ -6,18 +6,20 @@ source CoffeeScript into JavaScript.</p>
 <p>If included on a webpage, it will automatically sniff out, compile, and
 execute all scripts present in <code>text/coffeescript</code> tags.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">fs               = </span><span class="nx">require</span> <span class="s1">&#39;fs&#39;</span>
 <span class="nv">path             = </span><span class="nx">require</span> <span class="s1">&#39;path&#39;</span>
+<span class="p">{</span><span class="nx">Script</span><span class="p">}</span>         <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;vm&#39;</span>
+<span class="nv">Module           = </span><span class="nx">require</span> <span class="s1">&#39;module&#39;</span>
 <span class="p">{</span><span class="nx">Lexer</span><span class="p">,</span><span class="nx">RESERVED</span><span class="p">}</span> <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;./lexer&#39;</span>
 <span class="p">{</span><span class="nx">parser</span><span class="p">}</span>         <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;./parser&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-2">&#182;</a>               </div>               <p>TODO: Remove registerExtension when fully deprecated.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">if</span> <span class="nx">require</span><span class="p">.</span><span class="nx">extensions</span>
   <span class="nx">require</span><span class="p">.</span><span class="nx">extensions</span><span class="p">[</span><span class="s1">&#39;.coffee&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span><span class="nx">module</span><span class="p">,</span> <span class="nx">filename</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="nv">content = </span><span class="nx">compile</span> <span class="nx">fs</span><span class="p">.</span><span class="nx">readFileSync</span> <span class="nx">filename</span><span class="p">,</span> <span class="s1">&#39;utf8&#39;</span>
+    <span class="nv">content = </span><span class="nx">compile</span> <span class="nx">fs</span><span class="p">.</span><span class="nx">readFileSync</span><span class="p">(</span><span class="nx">filename</span><span class="p">,</span> <span class="s1">&#39;utf8&#39;</span><span class="p">),</span> <span class="p">{</span><span class="nx">filename</span><span class="p">}</span>
     <span class="nx">module</span><span class="p">.</span><span class="nx">_compile</span> <span class="nx">content</span><span class="p">,</span> <span class="nx">filename</span>
 <span class="k">else</span> <span class="k">if</span> <span class="nx">require</span><span class="p">.</span><span class="nx">registerExtension</span>
-  <span class="nx">require</span><span class="p">.</span><span class="nx">registerExtension</span> <span class="s1">&#39;.coffee&#39;</span><span class="p">,</span> <span class="p">(</span><span class="nx">content</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">compile</span> <span class="nx">content</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</a>               </div>               <p>The current CoffeeScript version number.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.VERSION = </span><span class="s1">&#39;1.0.0&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>Words that cannot be used as identifiers in CoffeeScript code</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.RESERVED = </span><span class="nx">RESERVED</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-5">&#182;</a>               </div>               <p>Expose helpers for testing.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.helpers = </span><span class="nx">require</span> <span class="s1">&#39;./helpers&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-6">&#182;</a>               </div>               <p>Compile a string of CoffeeScript code to JavaScript, using the Coffee/Jison
+  <span class="nx">require</span><span class="p">.</span><span class="nx">registerExtension</span> <span class="s1">&#39;.coffee&#39;</span><span class="p">,</span> <span class="p">(</span><span class="nx">content</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">compile</span> <span class="nx">content</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</a>               </div>               <p>The current CoffeeScript version number.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.VERSION = </span><span class="s1">&#39;1.1.2&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>Words that cannot be used as identifiers in CoffeeScript code</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.RESERVED = </span><span class="nx">RESERVED</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-5">&#182;</a>               </div>               <p>Expose helpers for testing.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.helpers = </span><span class="nx">require</span> <span class="s1">&#39;./helpers&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-6">&#182;</a>               </div>               <p>Compile a string of CoffeeScript code to JavaScript, using the Coffee/Jison
 compiler.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.compile = compile = </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nv">options = </span><span class="p">{})</span> <span class="o">-&gt;</span>
   <span class="k">try</span>
     <span class="p">(</span><span class="nx">parser</span><span class="p">.</span><span class="nx">parse</span> <span class="nx">lexer</span><span class="p">.</span><span class="nx">tokenize</span> <span class="nx">code</span><span class="p">).</span><span class="nx">compile</span> <span class="nx">options</span>
   <span class="k">catch</span> <span class="nx">err</span>
-    <span class="nv">err.message = </span><span class="s2">&quot;In #{options.fileName}, #{err.message}&quot;</span> <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">fileName</span>
+    <span class="nv">err.message = </span><span class="s2">&quot;In #{options.filename}, #{err.message}&quot;</span> <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">filename</span>
     <span class="k">throw</span> <span class="nx">err</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-7">&#182;</a>               </div>               <p>Tokenize a string of CoffeeScript code, and return the array of tokens.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.tokens = </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
   <span class="nx">lexer</span><span class="p">.</span><span class="nx">tokenize</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">options</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-8">&#182;</a>               </div>               <p>Parse a string of CoffeeScript code or an array of lexed tokens, and
 return the AST. You can then compile it by calling <code>.compile()</code> on the root,
@@ -26,16 +28,36 @@ or traverse it by using <code>.traverse()</code> with a callback.</p>
     <span class="nx">parser</span><span class="p">.</span><span class="nx">parse</span> <span class="nx">lexer</span><span class="p">.</span><span class="nx">tokenize</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">options</span>
   <span class="k">else</span>
     <span class="nx">parser</span><span class="p">.</span><span class="nx">parse</span> <span class="nx">source</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-9">&#182;</a>               </div>               <p>Compile and execute a string of CoffeeScript (on the server), correctly
-setting <code>__filename</code>, <code>__dirname</code>, and relative <code>require()</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.run = </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <p>We want the root module.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">root = </span><span class="nx">module</span>
-  <span class="k">while</span> <span class="nx">root</span><span class="p">.</span><span class="nx">parent</span>
-    <span class="nv">root = </span><span class="nx">root</span><span class="p">.</span><span class="nx">parent</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-11">&#182;</a>               </div>               <p>Set the filename.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">root.filename = </span><span class="nx">fs</span><span class="p">.</span><span class="nx">realpathSync</span> <span class="nx">options</span><span class="p">.</span><span class="nx">fileName</span> <span class="o">or</span> <span class="s1">&#39;.&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#182;</a>               </div>               <p>Clear the module cache.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">root.moduleCache = </span><span class="p">{}</span> <span class="k">if</span> <span class="nx">root</span><span class="p">.</span><span class="nx">moduleCache</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-13">&#182;</a>               </div>               <p>Compile.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">if</span> <span class="nx">path</span><span class="p">.</span><span class="nx">extname</span><span class="p">(</span><span class="nx">root</span><span class="p">.</span><span class="nx">filename</span><span class="p">)</span> <span class="o">isnt</span> <span class="s1">&#39;.coffee&#39;</span> <span class="o">or</span> <span class="nx">require</span><span class="p">.</span><span class="nx">extensions</span>
-    <span class="nx">root</span><span class="p">.</span><span class="nx">_compile</span> <span class="nx">compile</span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">),</span> <span class="nx">root</span><span class="p">.</span><span class="nx">filename</span>
+setting <code>__filename</code>, <code>__dirname</code>, and relative <code>require()</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.run = </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nv">mainModule = </span><span class="nx">require</span><span class="p">.</span><span class="nx">main</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <p>Set the filename.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nv">mainModule.filename = </span><span class="nx">process</span><span class="p">.</span><span class="nx">argv</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span>
+      <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">filename</span> <span class="k">then</span> <span class="nx">fs</span><span class="p">.</span><span class="nx">realpathSync</span><span class="p">(</span><span class="nx">options</span><span class="p">.</span><span class="nx">filename</span><span class="p">)</span> <span class="k">else</span> <span class="s1">&#39;.&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-11">&#182;</a>               </div>               <p>Clear the module cache.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">mainModule</span><span class="p">.</span><span class="nx">moduleCache</span> <span class="o">and=</span> <span class="p">{}</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#182;</a>               </div>               <p>Assign paths for node_modules loading</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">if</span> <span class="nx">process</span><span class="p">.</span><span class="nx">binding</span><span class="p">(</span><span class="s1">&#39;natives&#39;</span><span class="p">).</span><span class="nx">module</span>
+    <span class="p">{</span><span class="nx">Module</span><span class="p">}</span> <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;module&#39;</span>
+    <span class="nv">mainModule.paths = </span><span class="nx">Module</span><span class="p">.</span><span class="nx">_nodeModulePaths</span> <span class="nx">path</span><span class="p">.</span><span class="nx">dirname</span> <span class="nx">options</span><span class="p">.</span><span class="nx">filename</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-13">&#182;</a>               </div>               <p>Compile.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="k">if</span> <span class="nx">path</span><span class="p">.</span><span class="nx">extname</span><span class="p">(</span><span class="nx">mainModule</span><span class="p">.</span><span class="nx">filename</span><span class="p">)</span> <span class="o">isnt</span> <span class="s1">&#39;.coffee&#39;</span> <span class="o">or</span> <span class="nx">require</span><span class="p">.</span><span class="nx">extensions</span>
+    <span class="nx">mainModule</span><span class="p">.</span><span class="nx">_compile</span> <span class="nx">compile</span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">),</span> <span class="nx">mainModule</span><span class="p">.</span><span class="nx">filename</span>
   <span class="k">else</span>
-    <span class="nx">root</span><span class="p">.</span><span class="nx">_compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">root</span><span class="p">.</span><span class="nx">filename</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-14">&#182;</a>               </div>               <p>Compile and evaluate a string of CoffeeScript (in a Node.js-like environment).
-The CoffeeScript REPL uses this to run the input.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.eval = </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
-  <span class="nv">__filename = </span><span class="nx">options</span><span class="p">.</span><span class="nx">fileName</span>
-  <span class="nv">__dirname  = </span><span class="nx">path</span><span class="p">.</span><span class="nx">dirname</span> <span class="nx">__filename</span>
-  <span class="nb">eval</span> <span class="nx">compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">options</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-15">&#182;</a>               </div>               <p>Instantiate a Lexer for our use here.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">lexer = </span><span class="k">new</span> <span class="nx">Lexer</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#182;</a>               </div>               <p>The real Lexer produces a generic stream of tokens. This object provides a
+    <span class="nx">mainModule</span><span class="p">.</span><span class="nx">_compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">mainModule</span><span class="p">.</span><span class="nx">filename</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-14">&#182;</a>               </div>               <p>Compile and evaluate a string of CoffeeScript (in a Node.js-like environment).
+The CoffeeScript REPL uses this to run the input.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.eval = </span><span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nv">options = </span><span class="p">{})</span> <span class="o">-&gt;</span>
+  <span class="k">return</span> <span class="nx">unless</span> <span class="nv">code = </span><span class="nx">code</span><span class="p">.</span><span class="nx">trim</span><span class="p">()</span>
+  <span class="nv">sandbox = </span><span class="nx">Script</span><span class="p">.</span><span class="nx">createContext</span><span class="p">()</span>
+  <span class="nv">sandbox.global = sandbox.root = sandbox.GLOBAL = </span><span class="nx">sandbox</span>
+  <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">sandbox</span><span class="o">?</span>
+    <span class="k">if</span> <span class="nx">options</span><span class="p">.</span><span class="nx">sandbox</span> <span class="k">instanceof</span> <span class="nx">sandbox</span><span class="p">.</span><span class="nx">constructor</span>
+      <span class="nv">sandbox = </span><span class="nx">options</span><span class="p">.</span><span class="nx">sandbox</span>
+    <span class="k">else</span>
+      <span class="nx">sandbox</span><span class="p">[</span><span class="nx">k</span><span class="p">]</span> <span class="o">=</span> <span class="nx">v</span> <span class="k">for</span> <span class="nx">own</span> <span class="nx">k</span><span class="p">,</span> <span class="nx">v</span> <span class="k">of</span> <span class="nx">options</span><span class="p">.</span><span class="nx">sandbox</span>
+  <span class="nv">sandbox.__filename = </span><span class="nx">options</span><span class="p">.</span><span class="nx">filename</span> <span class="o">||</span> <span class="s1">&#39;eval&#39;</span>
+  <span class="nv">sandbox.__dirname  = </span><span class="nx">path</span><span class="p">.</span><span class="nx">dirname</span> <span class="nx">sandbox</span><span class="p">.</span><span class="nx">__filename</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-15">&#182;</a>               </div>               <p>define module/require only if they chose not to specify their own</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">unless</span> <span class="nx">sandbox</span><span class="p">.</span><span class="nx">module</span> <span class="o">or</span> <span class="nx">sandbox</span><span class="p">.</span><span class="nx">require</span>
+    <span class="nv">Module = </span><span class="nx">require</span> <span class="s1">&#39;module&#39;</span>
+    <span class="nv">sandbox.module  = _module  = </span><span class="k">new</span> <span class="nx">Module</span><span class="p">(</span><span class="nx">options</span><span class="p">.</span><span class="nx">modulename</span> <span class="o">||</span> <span class="s1">&#39;eval&#39;</span><span class="p">)</span>
+    <span class="nv">sandbox.require = _require = </span><span class="p">(</span><span class="nx">path</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">Module</span><span class="p">.</span><span class="nx">_load</span> <span class="nx">path</span><span class="p">,</span> <span class="nx">_module</span>
+    <span class="nv">_module.filename = </span><span class="nx">sandbox</span><span class="p">.</span><span class="nx">__filename</span>
+    <span class="nx">_require</span><span class="p">[</span><span class="nx">r</span><span class="p">]</span> <span class="o">=</span> <span class="nx">require</span><span class="p">[</span><span class="nx">r</span><span class="p">]</span> <span class="k">for</span> <span class="nx">r</span> <span class="k">in</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">getOwnPropertyNames</span> <span class="nx">require</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#182;</a>               </div>               <p>use the same hack node currently uses for their own REPL</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="nv">_require.paths = _module.paths = </span><span class="nx">Module</span><span class="p">.</span><span class="nx">_nodeModulePaths</span> <span class="nx">process</span><span class="p">.</span><span class="nx">cwd</span><span class="p">()</span>
+    <span class="nv">_require.resolve = </span><span class="p">(</span><span class="nx">request</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">Module</span><span class="p">.</span><span class="nx">_resolveFilename</span> <span class="nx">request</span><span class="p">,</span> <span class="nx">_module</span>
+  <span class="nv">o = </span><span class="p">{}</span>
+  <span class="nx">o</span><span class="p">[</span><span class="nx">k</span><span class="p">]</span> <span class="o">=</span> <span class="nx">v</span> <span class="k">for</span> <span class="nx">own</span> <span class="nx">k</span><span class="p">,</span> <span class="nx">v</span> <span class="k">of</span> <span class="nx">options</span>
+  <span class="nv">o.bare = </span><span class="kc">on</span> <span class="c1"># ensure return value</span>
+  <span class="nv">js = </span><span class="nx">compile</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">o</span>
+  <span class="nx">Script</span><span class="p">.</span><span class="nx">runInContext</span> <span class="nx">js</span><span class="p">,</span> <span class="nx">sandbox</span></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-17">&#182;</a>               </div>               <p>Instantiate a Lexer for our use here.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">lexer = </span><span class="k">new</span> <span class="nx">Lexer</span></pre></div>             </td>           </tr>                               <tr id="section-18">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-18">&#182;</a>               </div>               <p>The real Lexer produces a generic stream of tokens. This object provides a
 thin wrapper around it, compatible with the Jison API. We can then pass it
 directly as a "Jison lexer".</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">parser.lexer =</span>
   <span class="nx">lex</span><span class="o">:</span> <span class="o">-&gt;</span>

documentation/docs/command.html

@@ -1,10 +1,9 @@
 <!DOCTYPE html>  <html> <head>   <title>command.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>            <div id="jump_to">         Jump To &hellip;         <div id="jump_wrapper">           <div id="jump_page">                                           <a class="source" href="browser.html">                 browser.coffee               </a>                                           <a class="source" href="cake.html">                 cake.coffee               </a>                                           <a class="source" href="coffee-script.html">                 coffee-script.coffee               </a>                                           <a class="source" href="command.html">                 command.coffee               </a>                                           <a class="source" href="grammar.html">                 grammar.coffee               </a>                                           <a class="source" href="helpers.html">                 helpers.coffee               </a>                                           <a class="source" href="index.html">                 index.coffee               </a>                                           <a class="source" href="lexer.html">                 lexer.coffee               </a>                                           <a class="source" href="nodes.html">                 nodes.coffee               </a>                                           <a class="source" href="optparse.html">                 optparse.coffee               </a>                                           <a class="source" href="repl.html">                 repl.coffee               </a>                                           <a class="source" href="rewriter.html">                 rewriter.coffee               </a>                                           <a class="source" href="scope.html">                 scope.coffee               </a>                        </div>         </div>       </div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               command.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-1">&#182;</a>               </div>               <p>The <code>coffee</code> utility. Handles command-line compilation of CoffeeScript
 into various forms: saved into <code>.js</code> files or printed to stdout, piped to
-<a href="http://javascriptlint.com/">JSLint</a> or recompiled every time the source is
+<a href="http://javascriptlint.com/">JavaScript Lint</a> or recompiled every time the source is
 saved, printed as a token stream or as the syntax tree, or launch an
 interactive REPL.</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-2">&#182;</a>               </div>               <p>External dependencies.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">fs             = </span><span class="nx">require</span> <span class="s1">&#39;fs&#39;</span>
 <span class="nv">path           = </span><span class="nx">require</span> <span class="s1">&#39;path&#39;</span>
-<span class="nv">util           = </span><span class="nx">require</span> <span class="s1">&#39;util&#39;</span>
 <span class="nv">helpers        = </span><span class="nx">require</span> <span class="s1">&#39;./helpers&#39;</span>
 <span class="nv">optparse       = </span><span class="nx">require</span> <span class="s1">&#39;./optparse&#39;</span>
 <span class="nv">CoffeeScript   = </span><span class="nx">require</span> <span class="s1">&#39;./coffee-script&#39;</span>
@@ -18,10 +17,10 @@ interactive REPL.</p>             </td>             <td class="code">
   <span class="p">[</span><span class="s1">&#39;-c&#39;</span><span class="p">,</span> <span class="s1">&#39;--compile&#39;</span><span class="p">,</span>         <span class="s1">&#39;compile to JavaScript and save as .js files&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s1">&#39;-i&#39;</span><span class="p">,</span> <span class="s1">&#39;--interactive&#39;</span><span class="p">,</span>     <span class="s1">&#39;run an interactive CoffeeScript REPL&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s1">&#39;-o&#39;</span><span class="p">,</span> <span class="s1">&#39;--output [DIR]&#39;</span><span class="p">,</span>    <span class="s1">&#39;set the directory for compiled JavaScript&#39;</span><span class="p">]</span>
-  <span class="p">[</span><span class="s1">&#39;-j&#39;</span><span class="p">,</span> <span class="s1">&#39;--join&#39;</span><span class="p">,</span>            <span class="s1">&#39;concatenate the scripts before compiling&#39;</span><span class="p">]</span>
+  <span class="p">[</span><span class="s1">&#39;-j&#39;</span><span class="p">,</span> <span class="s1">&#39;--join [FILE]&#39;</span><span class="p">,</span>     <span class="s1">&#39;concatenate the scripts before compiling&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s1">&#39;-w&#39;</span><span class="p">,</span> <span class="s1">&#39;--watch&#39;</span><span class="p">,</span>           <span class="s1">&#39;watch scripts for changes, and recompile&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s1">&#39;-p&#39;</span><span class="p">,</span> <span class="s1">&#39;--print&#39;</span><span class="p">,</span>           <span class="s1">&#39;print the compiled JavaScript to stdout&#39;</span><span class="p">]</span>
-  <span class="p">[</span><span class="s1">&#39;-l&#39;</span><span class="p">,</span> <span class="s1">&#39;--lint&#39;</span><span class="p">,</span>            <span class="s1">&#39;pipe the compiled JavaScript through JSLint&#39;</span><span class="p">]</span>
+  <span class="p">[</span><span class="s1">&#39;-l&#39;</span><span class="p">,</span> <span class="s1">&#39;--lint&#39;</span><span class="p">,</span>            <span class="s1">&#39;pipe the compiled JavaScript through JavaScript Lint&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s1">&#39;-s&#39;</span><span class="p">,</span> <span class="s1">&#39;--stdio&#39;</span><span class="p">,</span>           <span class="s1">&#39;listen for and compile scripts over stdio&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s1">&#39;-e&#39;</span><span class="p">,</span> <span class="s1">&#39;--eval&#39;</span><span class="p">,</span>            <span class="s1">&#39;compile a string from the command line&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s1">&#39;-r&#39;</span><span class="p">,</span> <span class="s1">&#39;--require [FILE*]&#39;</span><span class="p">,</span> <span class="s1">&#39;require a library before executing your script&#39;</span><span class="p">]</span>
@@ -41,6 +40,7 @@ Many flags cause us to divert before compiling anything. Flags passed after
   <span class="k">return</span> <span class="nx">forkNode</span><span class="p">()</span>                      <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">nodejs</span>
   <span class="k">return</span> <span class="nx">usage</span><span class="p">()</span>                         <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">help</span>
   <span class="k">return</span> <span class="nx">version</span><span class="p">()</span>                       <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">version</span>
+  <span class="nx">loadRequires</span><span class="p">()</span>                         <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">require</span>
   <span class="k">return</span> <span class="nx">require</span> <span class="s1">&#39;./repl&#39;</span>                <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">interactive</span>
   <span class="k">return</span> <span class="nx">compileStdio</span><span class="p">()</span>                  <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">stdio</span>
   <span class="k">return</span> <span class="nx">compileScript</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">sources</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>  <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nb">eval</span>
@@ -48,34 +48,53 @@ Many flags cause us to divert before compiling anything. Flags passed after
   <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">run</span>
     <span class="nv">opts.literals = </span><span class="nx">sources</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="mi">1</span><span class="p">).</span><span class="nx">concat</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">literals</span>
   <span class="nv">process.ARGV = process.argv = </span><span class="nx">process</span><span class="p">.</span><span class="nx">argv</span><span class="p">.</span><span class="nx">slice</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">).</span><span class="nx">concat</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">literals</span>
+  <span class="nx">process</span><span class="p">.</span><span class="nx">argv</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;coffee&#39;</span>
+  <span class="nv">process.execPath = </span><span class="nx">require</span><span class="p">.</span><span class="nx">main</span><span class="p">.</span><span class="nx">filename</span>
   <span class="nx">compileScripts</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-8">&#182;</a>               </div>               <p>Asynchronously read in each CoffeeScript in a list of source files and
 compile them. If a directory is passed, recursively compile all
 '.coffee' extension source files in it and all subdirectories.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">compileScripts = </span><span class="o">-&gt;</span>
+  <span class="nv">unprocessed = </span><span class="p">[]</span>
+  <span class="k">for</span> <span class="nx">source</span> <span class="k">in</span> <span class="nx">sources</span>
+    <span class="nx">unprocessed</span><span class="p">[</span><span class="nx">sources</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">source</span><span class="p">)]</span><span class="o">=</span><span class="mi">1</span>
   <span class="k">for</span> <span class="nx">source</span> <span class="k">in</span> <span class="nx">sources</span>
     <span class="nv">base = </span><span class="nx">path</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="nx">source</span><span class="p">)</span>
-    <span class="nv">compile = </span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">topLevel</span><span class="p">)</span> <span class="o">-&gt;</span>
+    <span class="nv">compile = </span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">sourceIndex</span><span class="p">,</span> <span class="nx">topLevel</span><span class="p">)</span> <span class="o">-&gt;</span>
+      <span class="nv">remaining_files = </span><span class="o">-&gt;</span>
+        <span class="nv">total = </span><span class="mi">0</span>
+        <span class="nx">total</span> <span class="o">+=</span> <span class="nx">x</span> <span class="k">for</span> <span class="nx">x</span> <span class="k">in</span> <span class="nx">unprocessed</span>
+        <span class="nx">total</span>
       <span class="nx">path</span><span class="p">.</span><span class="nx">exists</span> <span class="nx">source</span><span class="p">,</span> <span class="p">(</span><span class="nx">exists</span><span class="p">)</span> <span class="o">-&gt;</span>
-        <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;File not found: #{source}&quot;</span> <span class="nx">unless</span> <span class="nx">exists</span>
+        <span class="k">if</span> <span class="nx">topLevel</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">exists</span> <span class="o">and</span> <span class="nx">source</span><span class="p">[</span><span class="o">-</span><span class="mi">7</span><span class="p">..]</span> <span class="o">isnt</span> <span class="s1">&#39;.coffee&#39;</span>
+            <span class="k">return</span> <span class="nx">compile</span> <span class="s2">&quot;#{source}.coffee&quot;</span><span class="p">,</span> <span class="nx">sourceIndex</span><span class="p">,</span> <span class="nx">topLevel</span>
+                
+        <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;File not found: #{source}&quot;</span> <span class="k">if</span> <span class="nx">topLevel</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">exists</span>
         <span class="nx">fs</span><span class="p">.</span><span class="nx">stat</span> <span class="nx">source</span><span class="p">,</span> <span class="p">(</span><span class="nx">err</span><span class="p">,</span> <span class="nx">stats</span><span class="p">)</span> <span class="o">-&gt;</span>
+          <span class="k">throw</span> <span class="nx">err</span> <span class="k">if</span> <span class="nx">err</span>
           <span class="k">if</span> <span class="nx">stats</span><span class="p">.</span><span class="nx">isDirectory</span><span class="p">()</span>
             <span class="nx">fs</span><span class="p">.</span><span class="nx">readdir</span> <span class="nx">source</span><span class="p">,</span> <span class="p">(</span><span class="nx">err</span><span class="p">,</span> <span class="nx">files</span><span class="p">)</span> <span class="o">-&gt;</span>
+              <span class="k">throw</span> <span class="nx">err</span> <span class="k">if</span> <span class="nx">err</span>
+              <span class="nx">unprocessed</span><span class="p">[</span><span class="nx">sourceIndex</span><span class="p">]</span> <span class="o">+=</span> <span class="nx">files</span><span class="p">.</span><span class="nx">length</span>
               <span class="k">for</span> <span class="nx">file</span> <span class="k">in</span> <span class="nx">files</span>
-                <span class="nx">compile</span> <span class="nx">path</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">file</span><span class="p">)</span>
+                <span class="nx">compile</span> <span class="nx">path</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">file</span><span class="p">),</span> <span class="nx">sourceIndex</span>
+              <span class="nx">unprocessed</span><span class="p">[</span><span class="nx">sourceIndex</span><span class="p">]</span> <span class="o">-=</span> <span class="mi">1</span>
           <span class="k">else</span> <span class="k">if</span> <span class="nx">topLevel</span> <span class="o">or</span> <span class="nx">path</span><span class="p">.</span><span class="nx">extname</span><span class="p">(</span><span class="nx">source</span><span class="p">)</span> <span class="o">is</span> <span class="s1">&#39;.coffee&#39;</span>
             <span class="nx">fs</span><span class="p">.</span><span class="nx">readFile</span> <span class="nx">source</span><span class="p">,</span> <span class="p">(</span><span class="nx">err</span><span class="p">,</span> <span class="nx">code</span><span class="p">)</span> <span class="o">-&gt;</span>
+              <span class="k">throw</span> <span class="nx">err</span> <span class="k">if</span> <span class="nx">err</span>
+              <span class="nx">unprocessed</span><span class="p">[</span><span class="nx">sourceIndex</span><span class="p">]</span> <span class="o">-=</span> <span class="mi">1</span>
               <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">join</span>
-                <span class="nx">contents</span><span class="p">[</span><span class="nx">sources</span><span class="p">.</span><span class="nx">indexOf</span> <span class="nx">source</span><span class="p">]</span> <span class="o">=</span> <span class="nx">code</span><span class="p">.</span><span class="nx">toString</span><span class="p">()</span>
-                <span class="nx">compileJoin</span><span class="p">()</span> <span class="k">if</span> <span class="nx">helpers</span><span class="p">.</span><span class="nx">compact</span><span class="p">(</span><span class="nx">contents</span><span class="p">).</span><span class="nx">length</span> <span class="o">is</span> <span class="nx">sources</span><span class="p">.</span><span class="nx">length</span>
+                <span class="nx">contents</span><span class="p">[</span><span class="nx">sourceIndex</span><span class="p">]</span> <span class="o">=</span> <span class="nx">helpers</span><span class="p">.</span><span class="nx">compact</span><span class="p">([</span><span class="nx">contents</span><span class="p">[</span><span class="nx">sourceIndex</span><span class="p">],</span> <span class="nx">code</span><span class="p">.</span><span class="nx">toString</span><span class="p">()]).</span><span class="nx">join</span><span class="p">(</span><span class="s1">&#39;\n&#39;</span><span class="p">)</span>
+                <span class="k">if</span> <span class="nx">helpers</span><span class="p">.</span><span class="nx">compact</span><span class="p">(</span><span class="nx">contents</span><span class="p">).</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="mi">0</span> <span class="o">and</span> <span class="nx">remaining_files</span><span class="p">()</span> <span class="o">==</span> <span class="mi">0</span>
+                  <span class="nx">compileJoin</span><span class="p">()</span>
               <span class="k">else</span>
                 <span class="nx">compileScript</span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">code</span><span class="p">.</span><span class="nx">toString</span><span class="p">(),</span> <span class="nx">base</span><span class="p">)</span>
             <span class="nx">watch</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">base</span> <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">watch</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">join</span>
-    <span class="nx">compile</span> <span class="nx">source</span><span class="p">,</span> <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-9">&#182;</a>               </div>               <p>Compile a single source script, containing the given code, according to the
+          <span class="k">else</span>
+            <span class="nx">unprocessed</span><span class="p">[</span><span class="nx">sourceIndex</span><span class="p">]</span> <span class="o">-=</span> <span class="mi">1</span>
+    <span class="nx">compile</span> <span class="nx">source</span><span class="p">,</span> <span class="nx">sources</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">source</span><span class="p">),</span> <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-9">&#182;</a>               </div>               <p>Compile a single source script, containing the given code, according to the
 requested options. If evaluating the script directly sets <code>__filename</code>,
 <code>__dirname</code> and <code>module.filename</code> to be correct relative to the script's path.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">compileScript = </span><span class="p">(</span><span class="nx">file</span><span class="p">,</span> <span class="nx">input</span><span class="p">,</span> <span class="nx">base</span><span class="p">)</span> <span class="o">-&gt;</span>
   <span class="nv">o = </span><span class="nx">opts</span>
   <span class="nv">options = </span><span class="nx">compileOptions</span> <span class="nx">file</span>
-  <span class="k">if</span> <span class="nx">o</span><span class="p">.</span><span class="nx">require</span>
-    <span class="nx">require</span><span class="p">(</span><span class="k">if</span> <span class="nx">helpers</span><span class="p">.</span><span class="nx">starts</span><span class="p">(</span><span class="nx">req</span><span class="p">,</span> <span class="s1">&#39;.&#39;</span><span class="p">)</span> <span class="k">then</span> <span class="nx">fs</span><span class="p">.</span><span class="nx">realpathSync</span><span class="p">(</span><span class="nx">req</span><span class="p">)</span> <span class="k">else</span> <span class="nx">req</span><span class="p">)</span> <span class="k">for</span> <span class="nx">req</span> <span class="k">in</span> <span class="nx">o</span><span class="p">.</span><span class="nx">require</span>
   <span class="k">try</span>
     <span class="nv">t = task = </span><span class="p">{</span><span class="nx">file</span><span class="p">,</span> <span class="nx">input</span><span class="p">,</span> <span class="nx">options</span><span class="p">}</span>
     <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">emit</span> <span class="s1">&#39;compile&#39;</span><span class="p">,</span> <span class="nx">task</span>
@@ -103,14 +122,18 @@ and write them back to <strong>stdout</strong>.</p>             </td>
     <span class="nx">compileScript</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">code</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-11">&#182;</a>               </div>               <p>After all of the source files are done being read, concatenate and compile
 them together.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">compileJoin = </span><span class="o">-&gt;</span>
   <span class="nv">code = </span><span class="nx">contents</span><span class="p">.</span><span class="nx">join</span> <span class="s1">&#39;\n&#39;</span>
-  <span class="nx">compileScript</span> <span class="s2">&quot;concatenation&quot;</span><span class="p">,</span> <span class="nx">code</span><span class="p">,</span> <span class="s2">&quot;concatenation&quot;</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#182;</a>               </div>               <p>Watch a source CoffeeScript file using <code>fs.watchFile</code>, recompiling it every
+  <span class="nx">compileScript</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">join</span><span class="p">,</span> <span class="nx">code</span><span class="p">,</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">join</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#182;</a>               </div>               <p>Load files that are to-be-required before compilation occurs.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">loadRequires = </span><span class="o">-&gt;</span>
+  <span class="nv">realFilename = </span><span class="nx">module</span><span class="p">.</span><span class="nx">filename</span>
+  <span class="nv">module.filename = </span><span class="s1">&#39;.&#39;</span>
+  <span class="nx">require</span> <span class="nx">req</span> <span class="k">for</span> <span class="nx">req</span> <span class="k">in</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">require</span>
+  <span class="nv">module.filename = </span><span class="nx">realFilename</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-13">&#182;</a>               </div>               <p>Watch a source CoffeeScript file using <code>fs.watchFile</code>, recompiling it every
 time the file is updated. May be used in combination with other options,
 such as <code>--lint</code> or <code>--print</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">watch = </span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">base</span><span class="p">)</span> <span class="o">-&gt;</span>
   <span class="nx">fs</span><span class="p">.</span><span class="nx">watchFile</span> <span class="nx">source</span><span class="p">,</span> <span class="p">{</span><span class="nx">persistent</span><span class="o">:</span> <span class="kc">true</span><span class="p">,</span> <span class="nx">interval</span><span class="o">:</span> <span class="mi">500</span><span class="p">},</span> <span class="p">(</span><span class="nx">curr</span><span class="p">,</span> <span class="nx">prev</span><span class="p">)</span> <span class="o">-&gt;</span>
     <span class="k">return</span> <span class="k">if</span> <span class="nx">curr</span><span class="p">.</span><span class="nx">size</span> <span class="o">is</span> <span class="nx">prev</span><span class="p">.</span><span class="nx">size</span> <span class="o">and</span> <span class="nx">curr</span><span class="p">.</span><span class="nx">mtime</span><span class="p">.</span><span class="nx">getTime</span><span class="p">()</span> <span class="o">is</span> <span class="nx">prev</span><span class="p">.</span><span class="nx">mtime</span><span class="p">.</span><span class="nx">getTime</span><span class="p">()</span>
     <span class="nx">fs</span><span class="p">.</span><span class="nx">readFile</span> <span class="nx">source</span><span class="p">,</span> <span class="p">(</span><span class="nx">err</span><span class="p">,</span> <span class="nx">code</span><span class="p">)</span> <span class="o">-&gt;</span>
       <span class="k">throw</span> <span class="nx">err</span> <span class="k">if</span> <span class="nx">err</span>
-      <span class="nx">compileScript</span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">code</span><span class="p">.</span><span class="nx">toString</span><span class="p">(),</span> <span class="nx">base</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-13">&#182;</a>               </div>               <p>Write out a JavaScript source file with the compiled code. By default, files
+      <span class="nx">compileScript</span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">code</span><span class="p">.</span><span class="nx">toString</span><span class="p">(),</span> <span class="nx">base</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-14">&#182;</a>               </div>               <p>Write out a JavaScript source file with the compiled code. By default, files
 are written out in <code>cwd</code> as <code>.js</code> files with the same name, but the output
 directory can be customized with <code>--output</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">writeJs = </span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">js</span><span class="p">,</span> <span class="nx">base</span><span class="p">)</span> <span class="o">-&gt;</span>
   <span class="nv">filename  = </span><span class="nx">path</span><span class="p">.</span><span class="nx">basename</span><span class="p">(</span><span class="nx">source</span><span class="p">,</span> <span class="nx">path</span><span class="p">.</span><span class="nx">extname</span><span class="p">(</span><span class="nx">source</span><span class="p">))</span> <span class="o">+</span> <span class="s1">&#39;.js&#39;</span>
@@ -121,10 +144,12 @@ directory can be customized with <code>--output</code>.</p>             </td>
   <span class="nv">compile   = </span><span class="o">-&gt;</span>
     <span class="nv">js = </span><span class="s1">&#39; &#39;</span> <span class="k">if</span> <span class="nx">js</span><span class="p">.</span><span class="nx">length</span> <span class="o">&lt;=</span> <span class="mi">0</span>
     <span class="nx">fs</span><span class="p">.</span><span class="nx">writeFile</span> <span class="nx">jsPath</span><span class="p">,</span> <span class="nx">js</span><span class="p">,</span> <span class="p">(</span><span class="nx">err</span><span class="p">)</span> <span class="o">-&gt;</span>
-      <span class="k">if</span> <span class="nx">err</span> <span class="k">then</span> <span class="nx">printLine</span> <span class="nx">err</span><span class="p">.</span><span class="nx">message</span>
-      <span class="k">else</span> <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">compile</span> <span class="o">and</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">watch</span> <span class="k">then</span> <span class="nx">util</span><span class="p">.</span><span class="nx">log</span> <span class="s2">&quot;compiled #{source}&quot;</span>
+      <span class="k">if</span> <span class="nx">err</span>
+        <span class="nx">printLine</span> <span class="nx">err</span><span class="p">.</span><span class="nx">message</span>
+      <span class="k">else</span> <span class="k">if</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">compile</span> <span class="o">and</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">watch</span>
+        <span class="nx">console</span><span class="p">.</span><span class="nx">log</span> <span class="s2">&quot;#{(new Date).toLocaleTimeString()} - compiled #{source}&quot;</span>
   <span class="nx">path</span><span class="p">.</span><span class="nx">exists</span> <span class="nx">dir</span><span class="p">,</span> <span class="p">(</span><span class="nx">exists</span><span class="p">)</span> <span class="o">-&gt;</span>
-    <span class="k">if</span> <span class="nx">exists</span> <span class="k">then</span> <span class="nx">compile</span><span class="p">()</span> <span class="k">else</span> <span class="nx">exec</span> <span class="s2">&quot;mkdir -p #{dir}&quot;</span><span class="p">,</span> <span class="nx">compile</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-14">&#182;</a>               </div>               <p>Pipe compiled JS through JSLint (requires a working <code>jsl</code> command), printing
+    <span class="k">if</span> <span class="nx">exists</span> <span class="k">then</span> <span class="nx">compile</span><span class="p">()</span> <span class="k">else</span> <span class="nx">exec</span> <span class="s2">&quot;mkdir -p #{dir}&quot;</span><span class="p">,</span> <span class="nx">compile</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-15">&#182;</a>               </div>               <p>Pipe compiled JS through JSLint (requires a working <code>jsl</code> command), printing
 any errors or warnings that arise.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">lint = </span><span class="p">(</span><span class="nx">file</span><span class="p">,</span> <span class="nx">js</span><span class="p">)</span> <span class="o">-&gt;</span>
   <span class="nv">printIt = </span><span class="p">(</span><span class="nx">buffer</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">printLine</span> <span class="nx">file</span> <span class="o">+</span> <span class="s1">&#39;:\t&#39;</span> <span class="o">+</span> <span class="nx">buffer</span><span class="p">.</span><span class="nx">toString</span><span class="p">().</span><span class="nx">trim</span><span class="p">()</span>
   <span class="nv">conf = </span><span class="nx">__dirname</span> <span class="o">+</span> <span class="s1">&#39;/../extras/jsl.conf&#39;</span>
@@ -132,18 +157,18 @@ any errors or warnings that arise.</p>             </td>             <td class="
   <span class="nx">jsl</span><span class="p">.</span><span class="nx">stdout</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;data&#39;</span><span class="p">,</span> <span class="nx">printIt</span>
   <span class="nx">jsl</span><span class="p">.</span><span class="nx">stderr</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;data&#39;</span><span class="p">,</span> <span class="nx">printIt</span>
   <span class="nx">jsl</span><span class="p">.</span><span class="nx">stdin</span><span class="p">.</span><span class="nx">write</span> <span class="nx">js</span>
-  <span class="nx">jsl</span><span class="p">.</span><span class="nx">stdin</span><span class="p">.</span><span class="nx">end</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-15">&#182;</a>               </div>               <p>Pretty-print a stream of tokens.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">printTokens = </span><span class="p">(</span><span class="nx">tokens</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">jsl</span><span class="p">.</span><span class="nx">stdin</span><span class="p">.</span><span class="nx">end</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#182;</a>               </div>               <p>Pretty-print a stream of tokens.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">printTokens = </span><span class="p">(</span><span class="nx">tokens</span><span class="p">)</span> <span class="o">-&gt;</span>
   <span class="nv">strings = </span><span class="k">for</span> <span class="nx">token</span> <span class="k">in</span> <span class="nx">tokens</span>
     <span class="p">[</span><span class="nx">tag</span><span class="p">,</span> <span class="nx">value</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nx">token</span><span class="p">[</span><span class="mi">1</span><span class="p">].</span><span class="nx">toString</span><span class="p">().</span><span class="nx">replace</span><span class="p">(</span><span class="sr">/\n/</span><span class="p">,</span> <span class="s1">&#39;\\n&#39;</span><span class="p">)]</span>
     <span class="s2">&quot;[#{tag} #{value}]&quot;</span>
-  <span class="nx">printLine</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s1">&#39; &#39;</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#182;</a>               </div>               <p>Use the <a href="optparse.html">OptionParser module</a> to extract all options from
+  <span class="nx">printLine</span> <span class="nx">strings</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s1">&#39; &#39;</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-17">&#182;</a>               </div>               <p>Use the <a href="optparse.html">OptionParser module</a> to extract all options from
 <code>process.argv</code> that are specified in <code>SWITCHES</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">parseOptions = </span><span class="o">-&gt;</span>
   <span class="nv">optionParser  = </span><span class="k">new</span> <span class="nx">optparse</span><span class="p">.</span><span class="nx">OptionParser</span> <span class="nx">SWITCHES</span><span class="p">,</span> <span class="nx">BANNER</span>
   <span class="nv">o = opts      = </span><span class="nx">optionParser</span><span class="p">.</span><span class="nx">parse</span> <span class="nx">process</span><span class="p">.</span><span class="nx">argv</span><span class="p">.</span><span class="nx">slice</span> <span class="mi">2</span>
   <span class="nx">o</span><span class="p">.</span><span class="nx">compile</span>     <span class="o">or=</span>  <span class="o">!!</span><span class="nx">o</span><span class="p">.</span><span class="nx">output</span>
   <span class="nv">o.run         = </span><span class="o">not</span> <span class="p">(</span><span class="nx">o</span><span class="p">.</span><span class="nx">compile</span> <span class="o">or</span> <span class="nx">o</span><span class="p">.</span><span class="nx">print</span> <span class="o">or</span> <span class="nx">o</span><span class="p">.</span><span class="nx">lint</span><span class="p">)</span>
   <span class="nv">o.print       = </span><span class="o">!!</span>  <span class="p">(</span><span class="nx">o</span><span class="p">.</span><span class="nx">print</span> <span class="o">or</span> <span class="p">(</span><span class="nx">o</span><span class="p">.</span><span class="nb">eval</span> <span class="o">or</span> <span class="nx">o</span><span class="p">.</span><span class="nx">stdio</span> <span class="o">and</span> <span class="nx">o</span><span class="p">.</span><span class="nx">compile</span><span class="p">))</span>
-  <span class="nv">sources       = </span><span class="nx">o</span><span class="p">.</span><span class="nx">arguments</span></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-17">&#182;</a>               </div>               <p>The compile-time options to pass to the CoffeeScript compiler.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">compileOptions = </span><span class="p">(</span><span class="nx">fileName</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="p">{</span><span class="nx">fileName</span><span class="p">,</span> <span class="nx">bare</span><span class="o">:</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">bare</span><span class="p">}</span></pre></div>             </td>           </tr>                               <tr id="section-18">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-18">&#182;</a>               </div>               <p>Start up a new Node.js instance with the arguments in <code>--nodejs</code> passed to
+  <span class="nv">sources       = </span><span class="nx">o</span><span class="p">.</span><span class="nx">arguments</span></pre></div>             </td>           </tr>                               <tr id="section-18">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-18">&#182;</a>               </div>               <p>The compile-time options to pass to the CoffeeScript compiler.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">compileOptions = </span><span class="p">(</span><span class="nx">filename</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="p">{</span><span class="nx">filename</span><span class="p">,</span> <span class="nx">bare</span><span class="o">:</span> <span class="nx">opts</span><span class="p">.</span><span class="nx">bare</span><span class="p">}</span></pre></div>             </td>           </tr>                               <tr id="section-19">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-19">&#182;</a>               </div>               <p>Start up a new Node.js instance with the arguments in <code>--nodejs</code> passed to
 the <code>node</code> binary, preserving the other options.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">forkNode = </span><span class="o">-&gt;</span>
   <span class="nv">nodeArgs = </span><span class="nx">opts</span><span class="p">.</span><span class="nx">nodejs</span><span class="p">.</span><span class="nx">split</span> <span class="sr">/\s+/</span>
   <span class="nv">args     = </span><span class="nx">process</span><span class="p">.</span><span class="nx">argv</span><span class="p">[</span><span class="mi">1</span><span class="p">..]</span>
@@ -151,11 +176,9 @@ the <code>node</code> binary, preserving the other options.</p>             </td
   <span class="nx">spawn</span> <span class="nx">process</span><span class="p">.</span><span class="nx">execPath</span><span class="p">,</span> <span class="nx">nodeArgs</span><span class="p">.</span><span class="nx">concat</span><span class="p">(</span><span class="nx">args</span><span class="p">),</span>
     <span class="nx">cwd</span><span class="o">:</span>        <span class="nx">process</span><span class="p">.</span><span class="nx">cwd</span><span class="p">()</span>
     <span class="nx">env</span><span class="o">:</span>        <span class="nx">process</span><span class="p">.</span><span class="nx">env</span>
-    <span class="nx">customFds</span><span class="o">:</span>  <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-19">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-19">&#182;</a>               </div>               <p>Print the <code>--help</code> usage message and exit. Deprecated switches are not
+    <span class="nx">customFds</span><span class="o">:</span>  <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-20">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-20">&#182;</a>               </div>               <p>Print the <code>--help</code> usage message and exit. Deprecated switches are not
 shown.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">usage = </span><span class="o">-&gt;</span>
-  <span class="nx">printLine</span> <span class="p">(</span><span class="k">new</span> <span class="nx">optparse</span><span class="p">.</span><span class="nx">OptionParser</span> <span class="nx">SWITCHES</span><span class="p">,</span> <span class="nx">BANNER</span><span class="p">).</span><span class="nx">help</span><span class="p">()</span>
-  <span class="nx">process</span><span class="p">.</span><span class="nx">exit</span> <span class="mi">0</span></pre></div>             </td>           </tr>                               <tr id="section-20">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-20">&#182;</a>               </div>               <p>Print the <code>--version</code> message and exit.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">version = </span><span class="o">-&gt;</span>
+  <span class="nx">printLine</span> <span class="p">(</span><span class="k">new</span> <span class="nx">optparse</span><span class="p">.</span><span class="nx">OptionParser</span> <span class="nx">SWITCHES</span><span class="p">,</span> <span class="nx">BANNER</span><span class="p">).</span><span class="nx">help</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-21">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-21">&#182;</a>               </div>               <p>Print the <code>--version</code> message and exit.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">version = </span><span class="o">-&gt;</span>
   <span class="nx">printLine</span> <span class="s2">&quot;CoffeeScript version #{CoffeeScript.VERSION}&quot;</span>
-  <span class="nx">process</span><span class="p">.</span><span class="nx">exit</span> <span class="mi">0</span>
 
 </pre></div>             </td>           </tr>                </tbody>     </table>   </div> </body> </html> 

documentation/docs/grammar.html

@@ -23,7 +23,7 @@ previous nonterminal.</p>             </td>             <td class="code">
   <span class="k">return</span> <span class="p">[</span><span class="nx">patternString</span><span class="p">,</span> <span class="s1">&#39;$$ = $1;&#39;</span><span class="p">,</span> <span class="nx">options</span><span class="p">]</span> <span class="nx">unless</span> <span class="nx">action</span>
   <span class="nv">action = </span><span class="k">if</span> <span class="nv">match = </span><span class="nx">unwrap</span><span class="p">.</span><span class="nx">exec</span> <span class="nx">action</span> <span class="k">then</span> <span class="nx">match</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="k">else</span> <span class="s2">&quot;(#{action}())&quot;</span>
   <span class="nv">action = </span><span class="nx">action</span><span class="p">.</span><span class="nx">replace</span> <span class="sr">/\bnew /g</span><span class="p">,</span> <span class="s1">&#39;$&amp;yy.&#39;</span>
-  <span class="nv">action = </span><span class="nx">action</span><span class="p">.</span><span class="nx">replace</span> <span class="sr">/\b(?:Expressions\.wrap|extend)\b/g</span><span class="p">,</span> <span class="s1">&#39;yy.$&amp;&#39;</span>
+  <span class="nv">action = </span><span class="nx">action</span><span class="p">.</span><span class="nx">replace</span> <span class="sr">/\b(?:Block\.wrap|extend)\b/g</span><span class="p">,</span> <span class="s1">&#39;yy.$&amp;&#39;</span>
   <span class="p">[</span><span class="nx">patternString</span><span class="p">,</span> <span class="s2">&quot;$$ = #{action};&quot;</span><span class="p">,</span> <span class="nx">options</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-6">&#182;</a>               </div>               <h2>Grammatical Rules</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-7">&#182;</a>               </div>               <p>In all of the rules that follow, you'll see the name of the nonterminal as
 the key to a list of alternative matches. With each match's action, the
 dollar-sign variables are provided by Jison as references to the value of
@@ -36,14 +36,14 @@ their numeric position, so in this rule:</p>
 for the <code>UNLESS</code> terminal, and <code>$3</code> would be the value of the second
 <code>Expression</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">grammar =</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-8">&#182;</a>               </div>               <p>The <strong>Root</strong> is the top-level node in the syntax tree. Since we parse bottom-up,
 all parsing must end here.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Root</span><span class="o">:</span> <span class="p">[</span>
-    <span class="nx">o</span> <span class="s1">&#39;&#39;</span><span class="p">,</span>                                       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Expressions</span>
+    <span class="nx">o</span> <span class="s1">&#39;&#39;</span><span class="p">,</span>                                       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Block</span>
     <span class="nx">o</span> <span class="s1">&#39;Body&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;Block TERMINATOR&#39;</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-9">&#182;</a>               </div>               <p>Any list of statements and expressions, separated by line breaks or semicolons.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Body</span><span class="o">:</span> <span class="p">[</span>
-    <span class="nx">o</span> <span class="s1">&#39;Line&#39;</span><span class="p">,</span>                                   <span class="o">-&gt;</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
+    <span class="nx">o</span> <span class="s1">&#39;Line&#39;</span><span class="p">,</span>                                   <span class="o">-&gt;</span> <span class="nx">Block</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s1">&#39;Body TERMINATOR Line&#39;</span><span class="p">,</span>                   <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">push</span> <span class="nx">$3</span>
     <span class="nx">o</span> <span class="s1">&#39;Body TERMINATOR&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <p>Expressions and statements, which make up a line in a body.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Line</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <p>Block and statements, which make up a line in a body.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Line</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;Expression&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;Statement&#39;</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-11">&#182;</a>               </div>               <p>Pure statements which cannot be expressions.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Statement</span><span class="o">:</span> <span class="p">[</span>
@@ -53,7 +53,7 @@ all parsing must end here.</p>             </td>             <td class="code">
     <span class="nx">o</span> <span class="s1">&#39;STATEMENT&#39;</span><span class="p">,</span>                              <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="nx">$1</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#182;</a>               </div>               <p>All the different types of expressions in our language. The basic unit of
 CoffeeScript is the <strong>Expression</strong> -- everything that can be an expression
-is one. Expressions serve as the building blocks of many other rules, making
+is one. Blocks serve as the building blocks of many other rules, making
 them somewhat circular.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Expression</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;Value&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;Invocation&#39;</span>
@@ -69,7 +69,7 @@ them somewhat circular.</p>             </td>             <td class="code">
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-13">&#182;</a>               </div>               <p>An indented block of expressions. Note that the <a href="rewriter.html">Rewriter</a>
 will convert some postfix forms into blocks for us, by adjusting the
 token stream.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Block</span><span class="o">:</span> <span class="p">[</span>
-    <span class="nx">o</span> <span class="s1">&#39;INDENT OUTDENT&#39;</span><span class="p">,</span>                         <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Expressions</span>
+    <span class="nx">o</span> <span class="s1">&#39;INDENT OUTDENT&#39;</span><span class="p">,</span>                         <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Block</span>
     <span class="nx">o</span> <span class="s1">&#39;INDENT Body OUTDENT&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="nx">$2</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-14">&#182;</a>               </div>               <p>A literal identifier, a variable name or property.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Identifier</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="nx">$1</span>
@@ -77,13 +77,15 @@ token stream.</p>             </td>             <td class="code">
 they can also serve as keys in object literals.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">AlphaNumeric</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span>                                 <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span>                                 <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#182;</a>               </div>               <p>All of our immediate values. These can (in general), be passed straight
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#182;</a>               </div>               <p>All of our immediate values. Generally these can be passed straight
 through and printed to JavaScript.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Literal</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;AlphaNumeric&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;JS&#39;</span><span class="p">,</span>                                     <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s1">&#39;REGEX&#39;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s1">&#39;BOOL&#39;</span><span class="p">,</span>                                   <span class="o">-&gt;</span>
-      <span class="k">new</span> <span class="nx">Literal</span> <span class="k">if</span> <span class="nx">$1</span> <span class="o">is</span> <span class="s1">&#39;undefined&#39;</span> <span class="k">then</span> <span class="s1">&#39;void 0&#39;</span> <span class="k">else</span> <span class="nx">$1</span>
+      <span class="nv">val = </span><span class="k">new</span> <span class="nx">Literal</span> <span class="nx">$1</span>
+      <span class="nv">val.isUndefined = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">$1</span> <span class="o">is</span> <span class="s1">&#39;undefined&#39;</span>
+      <span class="nx">val</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-17">&#182;</a>               </div>               <p>Assignment of a variable, property, or index to a value.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Assign</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;Assignable = Expression&#39;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Assign</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
     <span class="nx">o</span> <span class="s1">&#39;Assignable = INDENT Expression OUTDENT&#39;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Assign</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$4</span>
@@ -106,7 +108,7 @@ the ordinary <strong>Assign</strong> is that these allow numbers and strings as
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-20">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-20">&#182;</a>               </div>               <p>A block comment.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Comment</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;HERECOMMENT&#39;</span><span class="p">,</span>                            <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Comment</span> <span class="nx">$1</span>
   <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-21">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-21">&#182;</a>               </div>               <p>The <strong>Code</strong> node is the function literal. It's defined by an indented block
-of <strong>Expressions</strong> preceded by a function arrow, with an optional parameter
+of <strong>Block</strong> preceded by a function arrow, with an optional parameter
 list.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Code</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;PARAM_START ParamList PARAM_END FuncGlyph Block&#39;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Code</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$5</span><span class="p">,</span> <span class="nx">$4</span>
     <span class="nx">o</span> <span class="s1">&#39;FuncGlyph Block&#39;</span><span class="p">,</span>                        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Code</span> <span class="p">[],</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$1</span>
@@ -126,53 +128,55 @@ that hoovers up the remaining arguments.</p>             </td>             <td c
     <span class="nx">o</span> <span class="s1">&#39;ParamVar&#39;</span><span class="p">,</span>                               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Param</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s1">&#39;ParamVar ...&#39;</span><span class="p">,</span>                           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Param</span> <span class="nx">$1</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="kc">on</span>
     <span class="nx">o</span> <span class="s1">&#39;ParamVar = Expression&#39;</span><span class="p">,</span>                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Param</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
-  <span class="p">]</span>
-
-  <span class="nx">ParamVar</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#182;</a>               </div>               <p>Function Parameters</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">ParamVar</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;Identifier&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;ThisProperty&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;Array&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;Object&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#182;</a>               </div>               <p>A splat that occurs outside of a parameter list.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Splat</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-27">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-27">&#182;</a>               </div>               <p>A splat that occurs outside of a parameter list.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Splat</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;Expression ...&#39;</span><span class="p">,</span>                         <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Splat</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-27">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-27">&#182;</a>               </div>               <p>Variables and properties that can be assigned to.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">SimpleAssignable</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-28">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-28">&#182;</a>               </div>               <p>Variables and properties that can be assigned to.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">SimpleAssignable</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;Identifier&#39;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s1">&#39;Value Accessor&#39;</span><span class="p">,</span>                         <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">push</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s1">&#39;Invocation Accessor&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span><span class="p">,</span> <span class="p">[</span><span class="nx">$2</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s1">&#39;ThisProperty&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-28">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-28">&#182;</a>               </div>               <p>Everything that can be assigned to.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Assignable</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-29">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-29">&#182;</a>               </div>               <p>Everything that can be assigned to.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Assignable</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;SimpleAssignable&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;Array&#39;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s1">&#39;Object&#39;</span><span class="p">,</span>                                 <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-29">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-29">&#182;</a>               </div>               <p>The types of things that can be treated as values -- assigned to, invoked
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-30">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-30">&#182;</a>               </div>               <p>The types of things that can be treated as values -- assigned to, invoked
 as functions, indexed into, named as a class, etc.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Value</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;Assignable&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;Literal&#39;</span><span class="p">,</span>                                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s1">&#39;Parenthetical&#39;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s1">&#39;Range&#39;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s1">&#39;This&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-30">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-30">&#182;</a>               </div>               <p>The general group of accessors into an object, by property, by prototype
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-31">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-31">&#182;</a>               </div>               <p>The general group of accessors into an object, by property, by prototype
 or by array index or slice.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Accessor</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;.  Identifier&#39;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Access</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s1">&#39;?. Identifier&#39;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Access</span> <span class="nx">$2</span><span class="p">,</span> <span class="s1">&#39;soak&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;:: Identifier&#39;</span><span class="p">,</span>                          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Access</span> <span class="nx">$2</span><span class="p">,</span> <span class="s1">&#39;proto&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;::&#39;</span><span class="p">,</span>                                     <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Access</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;prototype&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;Index&#39;</span>
-    <span class="nx">o</span> <span class="s1">&#39;Slice&#39;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Slice</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-31">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-31">&#182;</a>               </div>               <p>Indexing into an object or array using bracket notation.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Index</span><span class="o">:</span> <span class="p">[</span>
-    <span class="nx">o</span> <span class="s1">&#39;INDEX_START Expression INDEX_END&#39;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Index</span> <span class="nx">$2</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-32">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-32">&#182;</a>               </div>               <p>Indexing into an object or array using bracket notation.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Index</span><span class="o">:</span> <span class="p">[</span>
+    <span class="nx">o</span> <span class="s1">&#39;INDEX_START IndexValue INDEX_END&#39;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s1">&#39;INDEX_SOAK  Index&#39;</span><span class="p">,</span>                      <span class="o">-&gt;</span> <span class="nx">extend</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">soak</span> <span class="o">:</span> <span class="kc">yes</span>
     <span class="nx">o</span> <span class="s1">&#39;INDEX_PROTO Index&#39;</span><span class="p">,</span>                      <span class="o">-&gt;</span> <span class="nx">extend</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">proto</span><span class="o">:</span> <span class="kc">yes</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-32">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-32">&#182;</a>               </div>               <p>In CoffeeScript, an object literal is simply a list of assignments.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nb">Object</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span>
+
+  <span class="nx">IndexValue</span><span class="o">:</span> <span class="p">[</span>
+    <span class="nx">o</span> <span class="s1">&#39;Expression&#39;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Index</span> <span class="nx">$1</span>
+    <span class="nx">o</span> <span class="s1">&#39;Slice&#39;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Slice</span> <span class="nx">$1</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-33">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-33">&#182;</a>               </div>               <p>In CoffeeScript, an object literal is simply a list of assignments.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nb">Object</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;{ AssignList OptComma }&#39;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Obj</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">generated</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-33">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-33">&#182;</a>               </div>               <p>Assignment of properties within an object literal can be separated by
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-34">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-34">&#182;</a>               </div>               <p>Assignment of properties within an object literal can be separated by
 comma, as in JavaScript, or simply by newline.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">AssignList</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;&#39;</span><span class="p">,</span>                                                       <span class="o">-&gt;</span> <span class="p">[]</span>
     <span class="nx">o</span> <span class="s1">&#39;AssignObj&#39;</span><span class="p">,</span>                                              <span class="o">-&gt;</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s1">&#39;AssignList , AssignObj&#39;</span><span class="p">,</span>                                 <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">$3</span>
     <span class="nx">o</span> <span class="s1">&#39;AssignList OptComma TERMINATOR AssignObj&#39;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">$4</span>
     <span class="nx">o</span> <span class="s1">&#39;AssignList OptComma INDENT AssignList OptComma OUTDENT&#39;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">$4</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-34">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-34">&#182;</a>               </div>               <p>Class definitions have optional bodies of prototype property assignments,
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-35">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-35">&#182;</a>               </div>               <p>Class definitions have optional bodies of prototype property assignments,
 and optional references to the superclass.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Class</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;CLASS&#39;</span><span class="p">,</span>                                      <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Class</span>
     <span class="nx">o</span> <span class="s1">&#39;CLASS Block&#39;</span><span class="p">,</span>                                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Class</span> <span class="kc">null</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">$2</span>
@@ -182,35 +186,35 @@ and optional references to the superclass.</p>             </td>             <td
     <span class="nx">o</span> <span class="s1">&#39;CLASS SimpleAssignable Block&#39;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Class</span> <span class="nx">$2</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">$3</span>
     <span class="nx">o</span> <span class="s1">&#39;CLASS SimpleAssignable EXTENDS Value&#39;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Class</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$4</span>
     <span class="nx">o</span> <span class="s1">&#39;CLASS SimpleAssignable EXTENDS Value Block&#39;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Class</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$4</span><span class="p">,</span> <span class="nx">$5</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-35">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-35">&#182;</a>               </div>               <p>Ordinary function invocation, or a chained series of calls.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Invocation</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-36">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-36">&#182;</a>               </div>               <p>Ordinary function invocation, or a chained series of calls.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Invocation</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;Value OptFuncExist Arguments&#39;</span><span class="p">,</span>           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Call</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s1">&#39;Invocation OptFuncExist Arguments&#39;</span><span class="p">,</span>      <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Call</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s1">&#39;SUPER&#39;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Call</span> <span class="s1">&#39;super&#39;</span><span class="p">,</span> <span class="p">[</span><span class="k">new</span> <span class="nx">Splat</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;arguments&#39;</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s1">&#39;SUPER Arguments&#39;</span><span class="p">,</span>                        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Call</span> <span class="s1">&#39;super&#39;</span><span class="p">,</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-36">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-36">&#182;</a>               </div>               <p>An optional existence check on a function.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">OptFuncExist</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-37">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-37">&#182;</a>               </div>               <p>An optional existence check on a function.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">OptFuncExist</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;&#39;</span><span class="p">,</span>                                       <span class="o">-&gt;</span> <span class="kc">no</span>
     <span class="nx">o</span> <span class="s1">&#39;FUNC_EXIST&#39;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="kc">yes</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-37">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-37">&#182;</a>               </div>               <p>The list of arguments to a function call.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Arguments</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-38">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-38">&#182;</a>               </div>               <p>The list of arguments to a function call.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Arguments</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;CALL_START CALL_END&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="p">[]</span>
     <span class="nx">o</span> <span class="s1">&#39;CALL_START ArgList OptComma CALL_END&#39;</span><span class="p">,</span>   <span class="o">-&gt;</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-38">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-38">&#182;</a>               </div>               <p>A reference to the <em>this</em> current object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">This</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-39">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-39">&#182;</a>               </div>               <p>A reference to the <em>this</em> current object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">This</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;THIS&#39;</span><span class="p">,</span>                                   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;this&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;@&#39;</span><span class="p">,</span>                                      <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;this&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-39">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-39">&#182;</a>               </div>               <p>A reference to a property on <em>this</em>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">ThisProperty</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-40">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-40">&#182;</a>               </div>               <p>A reference to a property on <em>this</em>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">ThisProperty</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;@ Identifier&#39;</span><span class="p">,</span>                           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="k">new</span> <span class="nx">Literal</span><span class="p">(</span><span class="s1">&#39;this&#39;</span><span class="p">),</span> <span class="p">[</span><span class="k">new</span> <span class="nx">Access</span><span class="p">(</span><span class="nx">$2</span><span class="p">)],</span> <span class="s1">&#39;this&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-40">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-40">&#182;</a>               </div>               <p>The array literal.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nb">Array</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-41">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-41">&#182;</a>               </div>               <p>The array literal.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nb">Array</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;[ ]&#39;</span><span class="p">,</span>                                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Arr</span> <span class="p">[]</span>
     <span class="nx">o</span> <span class="s1">&#39;[ ArgList OptComma ]&#39;</span><span class="p">,</span>                   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Arr</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-41">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-41">&#182;</a>               </div>               <p>Inclusive and exclusive range dots.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">RangeDots</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-42">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-42">&#182;</a>               </div>               <p>Inclusive and exclusive range dots.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">RangeDots</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;..&#39;</span><span class="p">,</span>                                     <span class="o">-&gt;</span> <span class="s1">&#39;inclusive&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;...&#39;</span><span class="p">,</span>                                    <span class="o">-&gt;</span> <span class="s1">&#39;exclusive&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-42">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-42">&#182;</a>               </div>               <p>The CoffeeScript range literal.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Range</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-43">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-43">&#182;</a>               </div>               <p>The CoffeeScript range literal.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Range</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;[ Expression RangeDots Expression ]&#39;</span><span class="p">,</span>    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Range</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$4</span><span class="p">,</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-43">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-43">&#182;</a>               </div>               <p>Array slice literals.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Slice</span><span class="o">:</span> <span class="p">[</span>
-    <span class="nx">o</span> <span class="s1">&#39;INDEX_START Expression RangeDots Expression INDEX_END&#39;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Range</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$4</span><span class="p">,</span> <span class="nx">$3</span>
-    <span class="nx">o</span> <span class="s1">&#39;INDEX_START Expression RangeDots INDEX_END&#39;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Range</span> <span class="nx">$2</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">$3</span>
-    <span class="nx">o</span> <span class="s1">&#39;INDEX_START RangeDots Expression INDEX_END&#39;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Range</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-44">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-44">&#182;</a>               </div>               <p>The <strong>ArgList</strong> is both the list of objects passed into a function call,
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-44">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-44">&#182;</a>               </div>               <p>Array slice literals.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Slice</span><span class="o">:</span> <span class="p">[</span>
+    <span class="nx">o</span> <span class="s1">&#39;Expression RangeDots Expression&#39;</span><span class="p">,</span>        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Range</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">$2</span>
+    <span class="nx">o</span> <span class="s1">&#39;Expression RangeDots&#39;</span><span class="p">,</span>                   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Range</span> <span class="nx">$1</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">$2</span>
+    <span class="nx">o</span> <span class="s1">&#39;RangeDots Expression&#39;</span><span class="p">,</span>                   <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Range</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$1</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-45">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-45">&#182;</a>               </div>               <p>The <strong>ArgList</strong> is both the list of objects passed into a function call,
 as well as the contents of an array literal
 (i.e. comma-separated expressions). Newlines work as well.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">ArgList</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;Arg&#39;</span><span class="p">,</span>                                              <span class="o">-&gt;</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
@@ -218,46 +222,46 @@ as well as the contents of an array literal
     <span class="nx">o</span> <span class="s1">&#39;ArgList OptComma TERMINATOR Arg&#39;</span><span class="p">,</span>                  <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">$4</span>
     <span class="nx">o</span> <span class="s1">&#39;INDENT ArgList OptComma OUTDENT&#39;</span><span class="p">,</span>                  <span class="o">-&gt;</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s1">&#39;ArgList OptComma INDENT ArgList OptComma OUTDENT&#39;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">$4</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-45">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-45">&#182;</a>               </div>               <p>Valid arguments are Expressions or Splats.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Arg</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-46">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-46">&#182;</a>               </div>               <p>Valid arguments are Blocks or Splats.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Arg</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;Expression&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;Splat&#39;</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-46">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-46">&#182;</a>               </div>               <p>Just simple, comma-separated, required arguments (no fancy syntax). We need
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-47">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-47">&#182;</a>               </div>               <p>Just simple, comma-separated, required arguments (no fancy syntax). We need
 this to be separate from the <strong>ArgList</strong> for use in <strong>Switch</strong> blocks, where
 having the newlines wouldn't make sense.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">SimpleArgs</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;Expression&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;SimpleArgs , Expression&#39;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="p">[].</span><span class="nx">concat</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-47">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-47">&#182;</a>               </div>               <p>The variants of <em>try/catch/finally</em> exception handling blocks.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Try</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-48">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-48">&#182;</a>               </div>               <p>The variants of <em>try/catch/finally</em> exception handling blocks.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Try</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;TRY Block&#39;</span><span class="p">,</span>                              <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Try</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s1">&#39;TRY Block Catch&#39;</span><span class="p">,</span>                        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Try</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nx">$3</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s1">&#39;TRY Block FINALLY Block&#39;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Try</span> <span class="nx">$2</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="nx">$4</span>
     <span class="nx">o</span> <span class="s1">&#39;TRY Block Catch FINALLY Block&#39;</span><span class="p">,</span>          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Try</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nx">$3</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="nx">$5</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-48">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-48">&#182;</a>               </div>               <p>A catch clause names its error and runs a block of code.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Catch</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-49">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-49">&#182;</a>               </div>               <p>A catch clause names its error and runs a block of code.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Catch</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;CATCH Identifier Block&#39;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="p">[</span><span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span><span class="p">]</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-49">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-49">&#182;</a>               </div>               <p>Throw an exception object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Throw</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-50">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-50">&#182;</a>               </div>               <p>Throw an exception object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Throw</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;THROW Expression&#39;</span><span class="p">,</span>                       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Throw</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-50">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-50">&#182;</a>               </div>               <p>Parenthetical expressions. Note that the <strong>Parenthetical</strong> is a <strong>Value</strong>,
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-51">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-51">&#182;</a>               </div>               <p>Parenthetical expressions. Note that the <strong>Parenthetical</strong> is a <strong>Value</strong>,
 not an <strong>Expression</strong>, so if you need to use an expression in a place
 where only values are accepted, wrapping it in parentheses will always do
 the trick.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">Parenthetical</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;( Body )&#39;</span><span class="p">,</span>                               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Parens</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s1">&#39;( INDENT Body OUTDENT )&#39;</span><span class="p">,</span>                <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Parens</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-51">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-51">&#182;</a>               </div>               <p>The condition portion of a while loop.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">WhileSource</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-52">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-52">&#182;</a>               </div>               <p>The condition portion of a while loop.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">WhileSource</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;WHILE Expression&#39;</span><span class="p">,</span>                       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">While</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s1">&#39;WHILE Expression WHEN Expression&#39;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">While</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">guard</span><span class="o">:</span> <span class="nx">$4</span>
     <span class="nx">o</span> <span class="s1">&#39;UNTIL Expression&#39;</span><span class="p">,</span>                       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">While</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">invert</span><span class="o">:</span> <span class="kc">true</span>
     <span class="nx">o</span> <span class="s1">&#39;UNTIL Expression WHEN Expression&#39;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">While</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">invert</span><span class="o">:</span> <span class="kc">true</span><span class="p">,</span> <span class="nx">guard</span><span class="o">:</span> <span class="nx">$4</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-52">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-52">&#182;</a>               </div>               <p>The while loop can either be normal, with a block of expressions to execute,
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-53">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-53">&#182;</a>               </div>               <p>The while loop can either be normal, with a block of expressions to execute,
 or postfix, with a single expression. There is no do..while.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">While</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;WhileSource Block&#39;</span><span class="p">,</span>                      <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">addBody</span> <span class="nx">$2</span>
-    <span class="nx">o</span> <span class="s1">&#39;Statement  WhileSource&#39;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="nx">$2</span><span class="p">.</span><span class="nx">addBody</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
-    <span class="nx">o</span> <span class="s1">&#39;Expression WhileSource&#39;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="nx">$2</span><span class="p">.</span><span class="nx">addBody</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
+    <span class="nx">o</span> <span class="s1">&#39;Statement  WhileSource&#39;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="nx">$2</span><span class="p">.</span><span class="nx">addBody</span> <span class="nx">Block</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
+    <span class="nx">o</span> <span class="s1">&#39;Expression WhileSource&#39;</span><span class="p">,</span>                 <span class="o">-&gt;</span> <span class="nx">$2</span><span class="p">.</span><span class="nx">addBody</span> <span class="nx">Block</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s1">&#39;Loop&#39;</span><span class="p">,</span>                                   <span class="o">-&gt;</span> <span class="nx">$1</span>
   <span class="p">]</span>
 
   <span class="nx">Loop</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;LOOP Block&#39;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">While</span><span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;true&#39;</span><span class="p">).</span><span class="nx">addBody</span> <span class="nx">$2</span>
-    <span class="nx">o</span> <span class="s1">&#39;LOOP Expression&#39;</span><span class="p">,</span>                        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">While</span><span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;true&#39;</span><span class="p">).</span><span class="nx">addBody</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">$2</span><span class="p">]</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-53">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-53">&#182;</a>               </div>               <p>Array, object, and range comprehensions, at the most generic level.
+    <span class="nx">o</span> <span class="s1">&#39;LOOP Expression&#39;</span><span class="p">,</span>                        <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">While</span><span class="p">(</span><span class="k">new</span> <span class="nx">Literal</span> <span class="s1">&#39;true&#39;</span><span class="p">).</span><span class="nx">addBody</span> <span class="nx">Block</span><span class="p">.</span><span class="nx">wrap</span> <span class="p">[</span><span class="nx">$2</span><span class="p">]</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-54">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-54">&#182;</a>               </div>               <p>Array, object, and range comprehensions, at the most generic level.
 Comprehensions can either be normal, with a block of expressions to execute,
 or postfix, with a single expression.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">For</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;Statement  ForBody&#39;</span><span class="p">,</span>                     <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">For</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$2</span>
@@ -273,17 +277,17 @@ or postfix, with a single expression.</p>             </td>             <td clas
   <span class="nx">ForStart</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;FOR ForVariables&#39;</span><span class="p">,</span>                       <span class="o">-&gt;</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s1">&#39;FOR OWN ForVariables&#39;</span><span class="p">,</span>                   <span class="o">-&gt;</span> <span class="nv">$3.own = </span><span class="kc">yes</span><span class="p">;</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-54">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-54">&#182;</a>               </div>               <p>An array of all accepted values for a variable inside the loop.
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-55">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-55">&#182;</a>               </div>               <p>An array of all accepted values for a variable inside the loop.
 This enables support for pattern matching.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">ForValue</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;Identifier&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;Array&#39;</span><span class="p">,</span>                                  <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s1">&#39;Object&#39;</span><span class="p">,</span>                                 <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Value</span> <span class="nx">$1</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-55">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-55">&#182;</a>               </div>               <p>An array or range comprehension has variables for the current element
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-56">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-56">&#182;</a>               </div>               <p>An array or range comprehension has variables for the current element
 and (optional) reference to the current index. Or, <em>key, value</em>, in the case
 of object comprehensions.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">ForVariables</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;ForValue&#39;</span><span class="p">,</span>                               <span class="o">-&gt;</span> <span class="p">[</span><span class="nx">$1</span><span class="p">]</span>
     <span class="nx">o</span> <span class="s1">&#39;ForValue , ForValue&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="p">[</span><span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span><span class="p">]</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-56">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-56">&#182;</a>               </div>               <p>The source of a comprehension is an array or object with an optional guard
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-57">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-57">&#182;</a>               </div>               <p>The source of a comprehension is an array or object with an optional guard
 clause. If it's an array comprehension, you can also choose to step through
 in fixed-size increments.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">ForSource</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;FORIN Expression&#39;</span><span class="p">,</span>                               <span class="o">-&gt;</span> <span class="nx">source</span><span class="o">:</span> <span class="nx">$2</span>
@@ -305,21 +309,21 @@ in fixed-size increments.</p>             </td>             <td class="code">
   <span class="nx">Whens</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;When&#39;</span>
     <span class="nx">o</span> <span class="s1">&#39;Whens When&#39;</span><span class="p">,</span>                             <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">$2</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-57">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-57">&#182;</a>               </div>               <p>An individual <strong>When</strong> clause, with action.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">When</span><span class="o">:</span> <span class="p">[</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-58">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-58">&#182;</a>               </div>               <p>An individual <strong>When</strong> clause, with action.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">When</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;LEADING_WHEN SimpleArgs Block&#39;</span><span class="p">,</span>            <span class="o">-&gt;</span> <span class="p">[[</span><span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span><span class="p">]]</span>
     <span class="nx">o</span> <span class="s1">&#39;LEADING_WHEN SimpleArgs Block TERMINATOR&#39;</span><span class="p">,</span> <span class="o">-&gt;</span> <span class="p">[[</span><span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span><span class="p">]]</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-58">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-58">&#182;</a>               </div>               <p>The most basic form of <em>if</em> is a condition and an action. The following
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-59">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-59">&#182;</a>               </div>               <p>The most basic form of <em>if</em> is a condition and an action. The following
 if-related rules are broken up along these lines in order to avoid
 ambiguity.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">IfBlock</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;IF Expression Block&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">If</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">type</span><span class="o">:</span> <span class="nx">$1</span>
     <span class="nx">o</span> <span class="s1">&#39;IfBlock ELSE IF Expression Block&#39;</span><span class="p">,</span>       <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">addElse</span> <span class="k">new</span> <span class="nx">If</span> <span class="nx">$4</span><span class="p">,</span> <span class="nx">$5</span><span class="p">,</span> <span class="nx">type</span><span class="o">:</span> <span class="nx">$3</span>
-    <span class="nx">o</span> <span class="s1">&#39;IfBlock ELSE Block&#39;</span><span class="p">,</span>                     <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">addElse</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-59">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-59">&#182;</a>               </div>               <p>The full complement of <em>if</em> expressions, including postfix one-liner
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-60">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-60">&#182;</a>               </div>               <p>The full complement of <em>if</em> expressions, including postfix one-liner
 <em>if</em> and <em>unless</em>.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">If</span><span class="o">:</span> <span class="p">[</span>
     <span class="nx">o</span> <span class="s1">&#39;IfBlock&#39;</span>
-    <span class="nx">o</span> <span class="s1">&#39;Statement  POST_IF Expression&#39;</span><span class="p">,</span>          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">If</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span><span class="p">([</span><span class="nx">$1</span><span class="p">]),</span> <span class="nx">type</span><span class="o">:</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">statement</span><span class="o">:</span> <span class="kc">true</span>
-    <span class="nx">o</span> <span class="s1">&#39;Expression POST_IF Expression&#39;</span><span class="p">,</span>          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">If</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">Expressions</span><span class="p">.</span><span class="nx">wrap</span><span class="p">([</span><span class="nx">$1</span><span class="p">]),</span> <span class="nx">type</span><span class="o">:</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">statement</span><span class="o">:</span> <span class="kc">true</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-60">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-60">&#182;</a>               </div>               <p>Arithmetic and logical operators, working on one or more operands.
+    <span class="nx">o</span> <span class="s1">&#39;IfBlock ELSE Block&#39;</span><span class="p">,</span>                     <span class="o">-&gt;</span> <span class="nx">$1</span><span class="p">.</span><span class="nx">addElse</span> <span class="nx">$3</span>
+    <span class="nx">o</span> <span class="s1">&#39;Statement  POST_IF Expression&#39;</span><span class="p">,</span>          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">If</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">Block</span><span class="p">.</span><span class="nx">wrap</span><span class="p">([</span><span class="nx">$1</span><span class="p">]),</span> <span class="nx">type</span><span class="o">:</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">statement</span><span class="o">:</span> <span class="kc">true</span>
+    <span class="nx">o</span> <span class="s1">&#39;Expression POST_IF Expression&#39;</span><span class="p">,</span>          <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">If</span> <span class="nx">$3</span><span class="p">,</span> <span class="nx">Block</span><span class="p">.</span><span class="nx">wrap</span><span class="p">([</span><span class="nx">$1</span><span class="p">]),</span> <span class="nx">type</span><span class="o">:</span> <span class="nx">$2</span><span class="p">,</span> <span class="nx">statement</span><span class="o">:</span> <span class="kc">true</span>
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-61">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-61">&#182;</a>               </div>               <p>Arithmetic and logical operators, working on one or more operands.
 Here they are grouped by order of precedence. The actual precedence rules
 are defined at the bottom of the page. It would be shorter if we could
 combine most of these rules into a single generic <em>Operand OpSymbol Operand</em>
@@ -332,7 +336,7 @@ rules are necessary.</p>             </td>             <td class="code">
     <span class="nx">o</span> <span class="s1">&#39;-- SimpleAssignable&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</span> <span class="s1">&#39;--&#39;</span><span class="p">,</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s1">&#39;++ SimpleAssignable&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</span> <span class="s1">&#39;++&#39;</span><span class="p">,</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s1">&#39;SimpleAssignable --&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</span> <span class="s1">&#39;--&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="kc">true</span>
-    <span class="nx">o</span> <span class="s1">&#39;SimpleAssignable ++&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</span> <span class="s1">&#39;++&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-61">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-61">&#182;</a>               </div>               <p><a href="http://jashkenas.github.com/coffee-script/#existence">The existential operator</a>.</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="nx">o</span> <span class="s1">&#39;Expression ?&#39;</span><span class="p">,</span>                           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Existence</span> <span class="nx">$1</span>
+    <span class="nx">o</span> <span class="s1">&#39;SimpleAssignable ++&#39;</span><span class="p">,</span>                    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</span> <span class="s1">&#39;++&#39;</span><span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="kc">null</span><span class="p">,</span> <span class="kc">true</span></pre></div>             </td>           </tr>                               <tr id="section-62">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-62">&#182;</a>               </div>               <p><a href="http://jashkenas.github.com/coffee-script/#existence">The existential operator</a>.</p>             </td>             <td class="code">               <div class="highlight"><pre>    <span class="nx">o</span> <span class="s1">&#39;Expression ?&#39;</span><span class="p">,</span>                           <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Existence</span> <span class="nx">$1</span>
 
     <span class="nx">o</span> <span class="s1">&#39;Expression +  Expression&#39;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</span> <span class="s1">&#39;+&#39;</span> <span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
     <span class="nx">o</span> <span class="s1">&#39;Expression -  Expression&#39;</span><span class="p">,</span>               <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Op</span> <span class="s1">&#39;-&#39;</span> <span class="p">,</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
@@ -352,7 +356,7 @@ rules are necessary.</p>             </td>             <td class="code">
     <span class="nx">o</span> <span class="s1">&#39;SimpleAssignable COMPOUND_ASSIGN</span>
 <span class="s1">       INDENT Expression OUTDENT&#39;</span><span class="p">,</span>              <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Assign</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$4</span><span class="p">,</span> <span class="nx">$2</span>
     <span class="nx">o</span> <span class="s1">&#39;SimpleAssignable EXTENDS Expression&#39;</span><span class="p">,</span>    <span class="o">-&gt;</span> <span class="k">new</span> <span class="nx">Extends</span> <span class="nx">$1</span><span class="p">,</span> <span class="nx">$3</span>
-  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-62">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-62">&#182;</a>               </div>               <h2>Precedence</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-63">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-63">&#182;</a>               </div>               <p>Operators at the top of this list have higher precedence than the ones lower
+  <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-63">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-63">&#182;</a>               </div>               <h2>Precedence</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-64">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-64">&#182;</a>               </div>               <p>Operators at the top of this list have higher precedence than the ones lower
 down. Following these rules is what makes <code>2 + 3 * 4</code> parse as:</p>
 
 <pre><code>2 + (3 * 4)
@@ -378,7 +382,7 @@ down. Following these rules is what makes <code>2 + 3 * 4</code> parse as:</p>
   <span class="p">[</span><span class="s1">&#39;right&#39;</span><span class="p">,</span>     <span class="s1">&#39;FORIN&#39;</span><span class="p">,</span> <span class="s1">&#39;FOROF&#39;</span><span class="p">,</span> <span class="s1">&#39;BY&#39;</span><span class="p">,</span> <span class="s1">&#39;WHEN&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s1">&#39;right&#39;</span><span class="p">,</span>     <span class="s1">&#39;IF&#39;</span><span class="p">,</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;FOR&#39;</span><span class="p">,</span> <span class="s1">&#39;DO&#39;</span><span class="p">,</span> <span class="s1">&#39;WHILE&#39;</span><span class="p">,</span> <span class="s1">&#39;UNTIL&#39;</span><span class="p">,</span> <span class="s1">&#39;LOOP&#39;</span><span class="p">,</span> <span class="s1">&#39;SUPER&#39;</span><span class="p">,</span> <span class="s1">&#39;CLASS&#39;</span><span class="p">]</span>
   <span class="p">[</span><span class="s1">&#39;right&#39;</span><span class="p">,</span>     <span class="s1">&#39;POST_IF&#39;</span><span class="p">]</span>
-<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-64">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-64">&#182;</a>               </div>               <h2>Wrapping Up</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-65">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-65">&#182;</a>               </div>               <p>Finally, now what we have our <strong>grammar</strong> and our <strong>operators</strong>, we can create
+<span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-65">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-65">&#182;</a>               </div>               <h2>Wrapping Up</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-66">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-66">&#182;</a>               </div>               <p>Finally, now that we have our <strong>grammar</strong> and our <strong>operators</strong>, we can create
 our <strong>Jison.Parser</strong>. We do this by processing all of our rules, recording all
 terminals (every symbol which does not appear as the name of a rule above)
 as "tokens".</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">tokens = </span><span class="p">[]</span>
@@ -387,7 +391,7 @@ as "tokens".</p>             </td>             <td class="code">               <
     <span class="k">for</span> <span class="nx">token</span> <span class="k">in</span> <span class="nx">alt</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="nx">split</span> <span class="s1">&#39; &#39;</span>
       <span class="nx">tokens</span><span class="p">.</span><span class="nx">push</span> <span class="nx">token</span> <span class="nx">unless</span> <span class="nx">grammar</span><span class="p">[</span><span class="nx">token</span><span class="p">]</span>
     <span class="nx">alt</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="s2">&quot;return #{alt[1]}&quot;</span> <span class="k">if</span> <span class="nx">name</span> <span class="o">is</span> <span class="s1">&#39;Root&#39;</span>
-    <span class="nx">alt</span></pre></div>             </td>           </tr>                               <tr id="section-66">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-66">&#182;</a>               </div>               <p>Initialize the <strong>Parser</strong> with our list of terminal <strong>tokens</strong>, our <strong>grammar</strong>
+    <span class="nx">alt</span></pre></div>             </td>           </tr>                               <tr id="section-67">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-67">&#182;</a>               </div>               <p>Initialize the <strong>Parser</strong> with our list of terminal <strong>tokens</strong>, our <strong>grammar</strong>
 rules, and the name of the root. Reverse the operators because Jison orders
 precedence from low to high, and we have it high to low
 (as in <a href="http://dinosaur.compilertools.net/yacc/index.html">Yacc</a>).</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">exports.parser = </span><span class="k">new</span> <span class="nx">Parser</span>

documentation/docs/lexer.html

@@ -19,6 +19,7 @@ it has consumed.</p>
 
 <p>Before returning the token stream, run it through the <a href="rewriter.html">Rewriter</a>
 unless explicitly asked not to.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">tokenize</span><span class="o">:</span> <span class="p">(</span><span class="nx">code</span><span class="p">,</span> <span class="nv">opts = </span><span class="p">{})</span> <span class="o">-&gt;</span>
+    <span class="nv">code     = </span><span class="s2">&quot;\n#{code}&quot;</span> <span class="k">if</span> <span class="nx">WHITESPACE</span><span class="p">.</span><span class="nx">test</span> <span class="nx">code</span>
     <span class="nv">code     = </span><span class="nx">code</span><span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="sr">/\r/g</span><span class="p">,</span> <span class="s1">&#39;&#39;</span><span class="p">).</span><span class="nx">replace</span> <span class="nx">TRAILING_SPACES</span><span class="p">,</span> <span class="s1">&#39;&#39;</span>
 
     <span class="vi">@code    = </span><span class="nx">code</span>           <span class="c1"># The remainder of the source code.</span>
@@ -57,11 +58,11 @@ though <code>is</code> means <code>===</code> otherwise.</p>             </td>
       <span class="nx">@token</span> <span class="s1">&#39;OWN&#39;</span><span class="p">,</span> <span class="nx">id</span>
       <span class="k">return</span> <span class="nx">id</span><span class="p">.</span><span class="nx">length</span>
     <span class="nv">forcedIdentifier = </span><span class="nx">colon</span> <span class="o">or</span>
-      <span class="p">(</span><span class="nv">prev = </span><span class="nx">last</span> <span class="nx">@tokens</span><span class="p">)</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">prev</span><span class="p">.</span><span class="nx">spaced</span> <span class="o">and</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;.&#39;</span><span class="p">,</span> <span class="s1">&#39;?.&#39;</span><span class="p">,</span> <span class="s1">&#39;@&#39;</span><span class="p">,</span> <span class="s1">&#39;::&#39;</span><span class="p">]</span>
+      <span class="p">(</span><span class="nv">prev = </span><span class="nx">last</span> <span class="nx">@tokens</span><span class="p">)</span> <span class="o">and</span> <span class="p">(</span><span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;.&#39;</span><span class="p">,</span> <span class="s1">&#39;?.&#39;</span><span class="p">,</span> <span class="s1">&#39;::&#39;</span><span class="p">]</span> <span class="o">or</span>
+      <span class="o">not</span> <span class="nx">prev</span><span class="p">.</span><span class="nx">spaced</span> <span class="o">and</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;@&#39;</span><span class="p">)</span>
     <span class="nv">tag = </span><span class="s1">&#39;IDENTIFIER&#39;</span>
 
-    <span class="k">if</span> <span class="nx">id</span> <span class="k">in</span> <span class="nx">JS_KEYWORDS</span> <span class="o">or</span>
-       <span class="o">not</span> <span class="nx">forcedIdentifier</span> <span class="o">and</span> <span class="nx">id</span> <span class="k">in</span> <span class="nx">COFFEE_KEYWORDS</span>
+    <span class="k">if</span> <span class="o">not</span> <span class="nx">forcedIdentifier</span> <span class="o">and</span> <span class="p">(</span><span class="nx">id</span> <span class="k">in</span> <span class="nx">JS_KEYWORDS</span> <span class="o">or</span> <span class="nx">id</span> <span class="k">in</span> <span class="nx">COFFEE_KEYWORDS</span><span class="p">)</span>
       <span class="nv">tag = </span><span class="nx">id</span><span class="p">.</span><span class="nx">toUpperCase</span><span class="p">()</span>
       <span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;WHEN&#39;</span> <span class="o">and</span> <span class="nx">@tag</span><span class="p">()</span> <span class="k">in</span> <span class="nx">LINE_BREAK</span>
         <span class="nv">tag = </span><span class="s1">&#39;LEADING_WHEN&#39;</span>
@@ -90,7 +91,7 @@ though <code>is</code> means <code>===</code> otherwise.</p>             </td>
         <span class="nx">@identifierError</span> <span class="nx">id</span>
 
     <span class="nx">unless</span> <span class="nx">forcedIdentifier</span>
-      <span class="nv">id  = </span><span class="nx">COFFEE_ALIASES</span><span class="p">[</span><span class="nx">id</span><span class="p">]</span> <span class="k">if</span> <span class="nx">COFFEE_ALIASES</span><span class="p">.</span><span class="nx">hasOwnProperty</span> <span class="nx">id</span>
+      <span class="nv">id  = </span><span class="nx">COFFEE_ALIAS_MAP</span><span class="p">[</span><span class="nx">id</span><span class="p">]</span> <span class="k">if</span> <span class="nx">id</span> <span class="k">in</span> <span class="nx">COFFEE_ALIASES</span>
       <span class="nv">tag = </span><span class="k">switch</span> <span class="nx">id</span>
         <span class="k">when</span> <span class="s1">&#39;!&#39;</span>                                  <span class="k">then</span> <span class="s1">&#39;UNARY&#39;</span>
         <span class="k">when</span> <span class="s1">&#39;==&#39;</span><span class="p">,</span> <span class="s1">&#39;!=&#39;</span>                           <span class="k">then</span> <span class="s1">&#39;COMPARE&#39;</span>
@@ -135,11 +136,11 @@ preserve whitespace, but ignore indentation to the left.</p>             </td>
     <span class="nx">heredoc</span><span class="p">.</span><span class="nx">length</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#182;</a>               </div>               <p>Matches and consumes comments.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">commentToken</span><span class="o">:</span> <span class="o">-&gt;</span>
     <span class="k">return</span> <span class="mi">0</span> <span class="nx">unless</span> <span class="nv">match = </span><span class="nx">@chunk</span><span class="p">.</span><span class="nx">match</span> <span class="nx">COMMENT</span>
     <span class="p">[</span><span class="nx">comment</span><span class="p">,</span> <span class="nx">here</span><span class="p">]</span> <span class="o">=</span> <span class="nx">match</span>
-    <span class="nx">@line</span> <span class="o">+=</span> <span class="nx">count</span> <span class="nx">comment</span><span class="p">,</span> <span class="s1">&#39;\n&#39;</span>
     <span class="k">if</span> <span class="nx">here</span>
       <span class="nx">@token</span> <span class="s1">&#39;HERECOMMENT&#39;</span><span class="p">,</span> <span class="nx">@sanitizeHeredoc</span> <span class="nx">here</span><span class="p">,</span>
         <span class="nx">herecomment</span><span class="o">:</span> <span class="kc">true</span><span class="p">,</span> <span class="nx">indent</span><span class="o">:</span> <span class="nb">Array</span><span class="p">(</span><span class="nx">@indent</span> <span class="o">+</span> <span class="mi">1</span><span class="p">).</span><span class="nx">join</span><span class="p">(</span><span class="s1">&#39; &#39;</span><span class="p">)</span>
       <span class="nx">@token</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;\n&#39;</span>
+    <span class="nx">@line</span> <span class="o">+=</span> <span class="nx">count</span> <span class="nx">comment</span><span class="p">,</span> <span class="s1">&#39;\n&#39;</span>
     <span class="nx">comment</span><span class="p">.</span><span class="nx">length</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-13">&#182;</a>               </div>               <p>Matches JavaScript interpolated directly into the source via backticks.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">jsToken</span><span class="o">:</span> <span class="o">-&gt;</span>
     <span class="k">return</span> <span class="mi">0</span> <span class="nx">unless</span> <span class="nx">@chunk</span><span class="p">.</span><span class="nx">charAt</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> <span class="o">is</span> <span class="s1">&#39;`&#39;</span> <span class="o">and</span> <span class="nv">match = </span><span class="nx">JSTOKEN</span><span class="p">.</span><span class="nx">exec</span> <span class="nx">@chunk</span>
     <span class="nx">@token</span> <span class="s1">&#39;JS&#39;</span><span class="p">,</span> <span class="p">(</span><span class="nv">script = </span><span class="nx">match</span><span class="p">[</span><span class="mi">0</span><span class="p">]).</span><span class="nx">slice</span> <span class="mi">1</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span>
@@ -147,7 +148,11 @@ preserve whitespace, but ignore indentation to the left.</p>             </td>
 to distinguish from division, so we borrow some basic heuristics from
 JavaScript and Ruby.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">regexToken</span><span class="o">:</span> <span class="o">-&gt;</span>
     <span class="k">return</span> <span class="mi">0</span> <span class="k">if</span> <span class="nx">@chunk</span><span class="p">.</span><span class="nx">charAt</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> <span class="o">isnt</span> <span class="s1">&#39;/&#39;</span>
-    <span class="k">return</span> <span class="nx">@heregexToken</span> <span class="nx">match</span> <span class="k">if</span> <span class="nv">match = </span><span class="nx">HEREGEX</span><span class="p">.</span><span class="nx">exec</span> <span class="nx">@chunk</span>
+    <span class="k">if</span> <span class="nv">match = </span><span class="nx">HEREGEX</span><span class="p">.</span><span class="nx">exec</span> <span class="nx">@chunk</span>
+      <span class="nv">length = </span><span class="nx">@heregexToken</span> <span class="nx">match</span>
+      <span class="nx">@line</span> <span class="o">+=</span> <span class="nx">count</span> <span class="nx">match</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="s1">&#39;\n&#39;</span>
+      <span class="k">return</span> <span class="nx">length</span>
+
     <span class="nv">prev = </span><span class="nx">last</span> <span class="nx">@tokens</span>
     <span class="k">return</span> <span class="mi">0</span> <span class="k">if</span> <span class="nx">prev</span> <span class="o">and</span> <span class="p">(</span><span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">in</span> <span class="p">(</span><span class="k">if</span> <span class="nx">prev</span><span class="p">.</span><span class="nx">spaced</span> <span class="k">then</span> <span class="nx">NOT_REGEX</span> <span class="k">else</span> <span class="nx">NOT_SPACED_REGEX</span><span class="p">))</span>
     <span class="k">return</span> <span class="mi">0</span> <span class="nx">unless</span> <span class="nv">match = </span><span class="nx">REGEX</span><span class="p">.</span><span class="nx">exec</span> <span class="nx">@chunk</span>
@@ -276,8 +281,11 @@ parentheses that indicate a method call from regular parentheses, and so on.</p>
     <span class="nx">value</span><span class="p">.</span><span class="nx">length</span></pre></div>             </td>           </tr>                               <tr id="section-22">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-22">&#182;</a>               </div>               <h2>Token Manipulators</h2>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-23">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-23">&#182;</a>               </div>               <p>Sanitize a heredoc or herecomment by
 erasing all external indentation on the left-hand side.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">sanitizeHeredoc</span><span class="o">:</span> <span class="p">(</span><span class="nx">doc</span><span class="p">,</span> <span class="nx">options</span><span class="p">)</span> <span class="o">-&gt;</span>
     <span class="p">{</span><span class="nx">indent</span><span class="p">,</span> <span class="nx">herecomment</span><span class="p">}</span> <span class="o">=</span> <span class="nx">options</span>
-    <span class="k">return</span> <span class="nx">doc</span> <span class="k">if</span> <span class="nx">herecomment</span> <span class="o">and</span> <span class="mi">0</span> <span class="o">&gt;</span> <span class="nx">doc</span><span class="p">.</span><span class="nx">indexOf</span> <span class="s1">&#39;\n&#39;</span>
-    <span class="nx">unless</span> <span class="nx">herecomment</span>
+    <span class="k">if</span> <span class="nx">herecomment</span>
+      <span class="k">if</span> <span class="nx">HEREDOC_ILLEGAL</span><span class="p">.</span><span class="nx">test</span> <span class="nx">doc</span>
+        <span class="k">throw</span> <span class="k">new</span> <span class="nb">Error</span> <span class="s2">&quot;block comment cannot contain \&quot;*/\&quot;, starting on line #{@line + 1}&quot;</span>
+      <span class="k">return</span> <span class="nx">doc</span> <span class="k">if</span> <span class="nx">doc</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="s1">&#39;\n&#39;</span><span class="p">)</span> <span class="o">&lt;=</span> <span class="mi">0</span>
+    <span class="k">else</span>
       <span class="k">while</span> <span class="nv">match = </span><span class="nx">HEREDOC_INDENT</span><span class="p">.</span><span class="nx">exec</span> <span class="nx">doc</span>
         <span class="nv">attempt = </span><span class="nx">match</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
         <span class="nv">indent = </span><span class="nx">attempt</span> <span class="k">if</span> <span class="nx">indent</span> <span class="o">is</span> <span class="kc">null</span> <span class="o">or</span> <span class="mi">0</span> <span class="o">&lt;</span> <span class="nx">attempt</span><span class="p">.</span><span class="nx">length</span> <span class="o">&lt;</span> <span class="nx">indent</span><span class="p">.</span><span class="nx">length</span>
@@ -297,9 +305,10 @@ parameters specially in order to make things easier for the parser.</p>
           <span class="nx">stack</span><span class="p">.</span><span class="nx">push</span> <span class="nx">tok</span>
         <span class="k">when</span> <span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="s1">&#39;CALL_START&#39;</span>
           <span class="k">if</span> <span class="nx">stack</span><span class="p">.</span><span class="nx">length</span> <span class="k">then</span> <span class="nx">stack</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
-          <span class="k">else</span>
+          <span class="k">else</span> <span class="k">if</span> <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;(&#39;</span>
             <span class="nx">tok</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;PARAM_START&#39;</span>
             <span class="k">return</span> <span class="k">this</span>
+          <span class="k">else</span> <span class="k">return</span> <span class="k">this</span>
     <span class="k">this</span></pre></div>             </td>           </tr>                               <tr id="section-25">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-25">&#182;</a>               </div>               <p>Close up all remaining open blocks at the end of the file.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">closeIndentation</span><span class="o">:</span> <span class="o">-&gt;</span>
     <span class="nx">@outdentToken</span> <span class="nx">@indent</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#182;</a>               </div>               <p>The error for when you try to use a forbidden word in JavaScript as
 an identifier.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">identifierError</span><span class="o">:</span> <span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="o">-&gt;</span>
@@ -323,6 +332,8 @@ interpolations within strings, ad infinitum.</p>             </td>             <
           <span class="k">continue</span>
       <span class="k">if</span> <span class="nx">end</span> <span class="o">is</span> <span class="s1">&#39;}&#39;</span> <span class="o">and</span> <span class="nx">letter</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;&quot;&#39;</span><span class="p">,</span> <span class="s2">&quot;&#39;&quot;</span><span class="p">]</span>
         <span class="nx">stack</span><span class="p">.</span><span class="nx">push</span> <span class="nv">end = </span><span class="nx">letter</span>
+      <span class="k">else</span> <span class="k">if</span> <span class="nx">end</span> <span class="o">is</span> <span class="s1">&#39;}&#39;</span> <span class="o">and</span> <span class="nx">letter</span> <span class="o">is</span> <span class="s1">&#39;/&#39;</span> <span class="o">and</span> <span class="nv">match = </span><span class="p">(</span><span class="nx">HEREGEX</span><span class="p">.</span><span class="nx">exec</span><span class="p">(</span><span class="nx">str</span><span class="p">.</span><span class="nx">slice</span> <span class="nx">i</span><span class="p">)</span> <span class="o">or</span> <span class="nx">REGEX</span><span class="p">.</span><span class="nx">exec</span><span class="p">(</span><span class="nx">str</span><span class="p">.</span><span class="nx">slice</span> <span class="nx">i</span><span class="p">))</span>
+        <span class="nx">i</span> <span class="o">+=</span> <span class="nx">match</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
       <span class="k">else</span> <span class="k">if</span> <span class="nx">end</span> <span class="o">is</span> <span class="s1">&#39;}&#39;</span> <span class="o">and</span> <span class="nx">letter</span> <span class="o">is</span> <span class="s1">&#39;{&#39;</span>
         <span class="nx">stack</span><span class="p">.</span><span class="nx">push</span> <span class="nv">end = </span><span class="s1">&#39;}&#39;</span>
       <span class="k">else</span> <span class="k">if</span> <span class="nx">end</span> <span class="o">is</span> <span class="s1">&#39;&quot;&#39;</span> <span class="o">and</span> <span class="nx">prev</span> <span class="o">is</span> <span class="s1">&#39;#&#39;</span> <span class="o">and</span> <span class="nx">letter</span> <span class="o">is</span> <span class="s1">&#39;{&#39;</span>
@@ -354,10 +365,11 @@ token stream.</p>             </td>             <td class="code">
         <span class="nv">nested = </span><span class="k">new</span> <span class="nx">Lexer</span><span class="p">().</span><span class="nx">tokenize</span> <span class="nx">inner</span><span class="p">,</span> <span class="nx">line</span><span class="o">:</span> <span class="nx">@line</span><span class="p">,</span> <span class="nx">rewrite</span><span class="o">:</span> <span class="kc">off</span>
         <span class="nx">nested</span><span class="p">.</span><span class="nx">pop</span><span class="p">()</span>
         <span class="nx">nested</span><span class="p">.</span><span class="nx">shift</span><span class="p">()</span> <span class="k">if</span> <span class="nx">nested</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">?</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;TERMINATOR&#39;</span>
-        <span class="k">if</span> <span class="nx">nested</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="mi">1</span>
-          <span class="nx">nested</span><span class="p">.</span><span class="nx">unshift</span> <span class="p">[</span><span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="s1">&#39;(&#39;</span><span class="p">]</span>
-          <span class="nx">nested</span><span class="p">.</span><span class="nx">push</span>    <span class="p">[</span><span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">]</span>
-        <span class="nx">tokens</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="s1">&#39;TOKENS&#39;</span><span class="p">,</span> <span class="nx">nested</span><span class="p">]</span>
+        <span class="k">if</span> <span class="nv">len = </span><span class="nx">nested</span><span class="p">.</span><span class="nx">length</span>
+          <span class="k">if</span> <span class="nx">len</span> <span class="o">&gt;</span> <span class="mi">1</span>
+            <span class="nx">nested</span><span class="p">.</span><span class="nx">unshift</span> <span class="p">[</span><span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="s1">&#39;(&#39;</span><span class="p">]</span>
+            <span class="nx">nested</span><span class="p">.</span><span class="nx">push</span>    <span class="p">[</span><span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">]</span>
+          <span class="nx">tokens</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="s1">&#39;TOKENS&#39;</span><span class="p">,</span> <span class="nx">nested</span><span class="p">]</span>
       <span class="nx">i</span> <span class="o">+=</span> <span class="nx">expr</span><span class="p">.</span><span class="nx">length</span>
       <span class="nv">pi = </span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span>
     <span class="nx">tokens</span><span class="p">.</span><span class="nx">push</span> <span class="p">[</span><span class="s1">&#39;NEOSTRING&#39;</span><span class="p">,</span> <span class="nx">str</span><span class="p">.</span><span class="nx">slice</span> <span class="nx">pi</span><span class="p">]</span> <span class="k">if</span> <span class="nx">i</span> <span class="o">&gt;</span> <span class="nx">pi</span> <span class="o">&lt;</span> <span class="nx">str</span><span class="p">.</span><span class="nx">length</span>
@@ -392,7 +404,8 @@ token stream.</p>             </td>             <td class="code">
   <span class="s1">&#39;if&#39;</span><span class="p">,</span> <span class="s1">&#39;else&#39;</span><span class="p">,</span> <span class="s1">&#39;switch&#39;</span><span class="p">,</span> <span class="s1">&#39;for&#39;</span><span class="p">,</span> <span class="s1">&#39;while&#39;</span><span class="p">,</span> <span class="s1">&#39;do&#39;</span><span class="p">,</span> <span class="s1">&#39;try&#39;</span><span class="p">,</span> <span class="s1">&#39;catch&#39;</span><span class="p">,</span> <span class="s1">&#39;finally&#39;</span>
   <span class="s1">&#39;class&#39;</span><span class="p">,</span> <span class="s1">&#39;extends&#39;</span><span class="p">,</span> <span class="s1">&#39;super&#39;</span>
 <span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-39">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-39">&#182;</a>               </div>               <p>CoffeeScript-only keywords.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">COFFEE_KEYWORDS = </span><span class="p">[</span><span class="s1">&#39;undefined&#39;</span><span class="p">,</span> <span class="s1">&#39;then&#39;</span><span class="p">,</span> <span class="s1">&#39;unless&#39;</span><span class="p">,</span> <span class="s1">&#39;until&#39;</span><span class="p">,</span> <span class="s1">&#39;loop&#39;</span><span class="p">,</span> <span class="s1">&#39;of&#39;</span><span class="p">,</span> <span class="s1">&#39;by&#39;</span><span class="p">,</span> <span class="s1">&#39;when&#39;</span><span class="p">]</span>
-<span class="nx">COFFEE_KEYWORDS</span><span class="p">.</span><span class="nx">push</span> <span class="nx">op</span> <span class="k">for</span> <span class="nx">op</span> <span class="k">of</span> <span class="nv">COFFEE_ALIASES =</span>
+
+<span class="nv">COFFEE_ALIAS_MAP =</span>
   <span class="o">and</span>  <span class="o">:</span> <span class="s1">&#39;&amp;&amp;&#39;</span>
   <span class="o">or</span>   <span class="o">:</span> <span class="s1">&#39;||&#39;</span>
   <span class="o">is</span>   <span class="o">:</span> <span class="s1">&#39;==&#39;</span>
@@ -401,7 +414,10 @@ token stream.</p>             </td>             <td class="code">
   <span class="kc">yes</span>  <span class="o">:</span> <span class="s1">&#39;true&#39;</span>
   <span class="kc">no</span>   <span class="o">:</span> <span class="s1">&#39;false&#39;</span>
   <span class="kc">on</span>   <span class="o">:</span> <span class="s1">&#39;true&#39;</span>
-  <span class="kc">off</span>  <span class="o">:</span> <span class="s1">&#39;false&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-40">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-40">&#182;</a>               </div>               <p>The list of keywords that are reserved by JavaScript, but not used, or are
+  <span class="kc">off</span>  <span class="o">:</span> <span class="s1">&#39;false&#39;</span>
+
+<span class="nv">COFFEE_ALIASES  = </span><span class="p">(</span><span class="nx">key</span> <span class="k">for</span> <span class="nx">key</span> <span class="k">of</span> <span class="nx">COFFEE_ALIAS_MAP</span><span class="p">)</span>
+<span class="nv">COFFEE_KEYWORDS = </span><span class="nx">COFFEE_KEYWORDS</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">COFFEE_ALIASES</span></pre></div>             </td>           </tr>                               <tr id="section-40">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-40">&#182;</a>               </div>               <p>The list of keywords that are reserved by JavaScript, but not used, or are
 used by CoffeeScript internally. We throw an error when these are encountered,
 to avoid having a JavaScript error at runtime.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">RESERVED = </span><span class="p">[</span>
   <span class="s1">&#39;case&#39;</span><span class="p">,</span> <span class="s1">&#39;default&#39;</span><span class="p">,</span> <span class="s1">&#39;function&#39;</span><span class="p">,</span> <span class="s1">&#39;var&#39;</span><span class="p">,</span> <span class="s1">&#39;void&#39;</span><span class="p">,</span> <span class="s1">&#39;with&#39;</span>
@@ -411,13 +427,13 @@ to avoid having a JavaScript error at runtime.</p>             </td>
 be used as identifiers or properties.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">JS_FORBIDDEN = </span><span class="nx">JS_KEYWORDS</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">RESERVED</span>
 
 <span class="nv">exports.RESERVED = </span><span class="nx">RESERVED</span><span class="p">.</span><span class="nx">concat</span><span class="p">(</span><span class="nx">JS_KEYWORDS</span><span class="p">).</span><span class="nx">concat</span><span class="p">(</span><span class="nx">COFFEE_KEYWORDS</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-42">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-42">&#182;</a>               </div>               <p>Token matching regexes.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IDENTIFIER = </span><span class="err">/// ^</span>
-  <span class="p">(</span> <span class="p">[</span><span class="nx">$A</span><span class="o">-</span><span class="nx">Za</span><span class="o">-</span><span class="nx">z_</span><span class="p">][</span><span class="nx">$</span><span class="err">\</span><span class="nx">w</span><span class="p">]</span><span class="o">*</span> <span class="p">)</span>
+  <span class="p">(</span> <span class="p">[</span><span class="nx">$A</span><span class="o">-</span><span class="nx">Za</span><span class="o">-</span><span class="nx">z_</span><span class="err">\</span><span class="nx">x7f</span><span class="o">-</span><span class="err">\</span><span class="nx">uffff</span><span class="p">][</span><span class="nx">$</span><span class="err">\</span><span class="nx">w</span><span class="err">\</span><span class="nx">x7f</span><span class="o">-</span><span class="err">\</span><span class="nx">uffff</span><span class="p">]</span><span class="o">*</span> <span class="p">)</span>
   <span class="p">(</span> <span class="p">[</span><span class="o">^</span><span class="err">\</span><span class="nx">n</span><span class="err">\</span><span class="nx">S</span><span class="p">]</span><span class="o">*</span> <span class="o">:</span> <span class="p">(</span><span class="o">?!:</span><span class="p">)</span> <span class="p">)</span><span class="o">?</span>  <span class="c1"># Is this a property name?</span>
 <span class="err">///</span>
 
 <span class="nv">NUMBER     = </span><span class="err">///</span>
   <span class="o">^</span> <span class="mi">0</span><span class="nx">x</span><span class="p">[</span><span class="err">\</span><span class="nx">da</span><span class="o">-</span><span class="nx">f</span><span class="p">]</span><span class="o">+</span> <span class="o">|</span>                              <span class="c1"># hex</span>
-  <span class="o">^</span> <span class="p">(</span><span class="o">?:</span> <span class="err">\</span><span class="nx">d</span><span class="o">+</span><span class="p">(</span><span class="err">\</span><span class="p">.</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span><span class="p">)</span><span class="o">?</span> <span class="o">|</span> <span class="err">\</span><span class="p">.</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span> <span class="p">)</span> <span class="p">(</span><span class="o">?:</span><span class="nx">e</span><span class="p">[</span><span class="o">+-</span><span class="p">]</span><span class="o">?</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span><span class="p">)</span><span class="o">?</span>  <span class="c1"># decimal</span>
+  <span class="o">^</span> <span class="err">\</span><span class="nx">d</span><span class="o">*</span><span class="err">\</span><span class="p">.</span><span class="o">?</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span> <span class="p">(</span><span class="o">?:</span><span class="nx">e</span><span class="p">[</span><span class="o">+-</span><span class="p">]</span><span class="o">?</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span><span class="p">)</span><span class="o">?</span>  <span class="c1"># decimal</span>
 <span class="err">///i</span>
 
 <span class="nv">HEREDOC    = </span><span class="err">/// ^ (&quot;&quot;&quot;|&#39;&#39;&#39;) ([\s\S]*?) (?:\n[^\n\S]*)? \1 ///</span>
@@ -443,7 +459,7 @@ be used as identifiers or properties.</p>             </td>             <td clas
 <span class="nv">SIMPLESTR  = </span><span class="sr">/^&#39;[^\\&#39;]*(?:\\.[^\\&#39;]*)*&#39;/</span>
 
 <span class="nv">JSTOKEN    = </span><span class="sr">/^`[^\\`]*(?:\\.[^\\`]*)*`/</span></pre></div>             </td>           </tr>                               <tr id="section-43">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-43">&#182;</a>               </div>               <p>Regex-matching-regexes.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">REGEX = </span><span class="err">/// ^</span>
-  <span class="o">/</span> <span class="p">(</span><span class="o">?!</span> <span class="err">\</span><span class="nx">s</span> <span class="p">)</span>       <span class="c1"># disallow leading whitespace</span>
+  <span class="o">/</span> <span class="p">(</span><span class="o">?!</span> <span class="p">[</span><span class="err">\</span><span class="nx">s</span><span class="o">=</span><span class="p">]</span> <span class="p">)</span>       <span class="c1"># disallow leading whitespace or equals signs</span>
   <span class="p">[</span><span class="o">^</span> <span class="p">[</span> <span class="err">/ \n \\ ]*  # every other thing</span>
   <span class="p">(</span><span class="o">?:</span>
     <span class="p">(</span><span class="o">?:</span> <span class="err">\\</span><span class="p">[</span><span class="err">\</span><span class="nx">s</span><span class="err">\</span><span class="nx">S</span><span class="p">]</span>   <span class="c1"># anything escaped</span>
@@ -462,9 +478,11 @@ be used as identifiers or properties.</p>             </td>             <td clas
 
 <span class="nv">HEREDOC_INDENT  = </span><span class="sr">/\n+([^\n\S]*)/g</span>
 
-<span class="nv">ASSIGNED        = </span><span class="sr">/^\s*@?([$A-Za-z_][$\w]*|[&#39;&quot;].*[&#39;&quot;])[^\n\S]*?[:=][^:=&gt;]/</span>
+<span class="nv">HEREDOC_ILLEGAL = </span><span class="sr">/\*\//</span>
 
-<span class="nv">LINE_CONTINUER  = </span><span class="err">/// ^ \s* (?: , | \??\.(?!\.) | :: ) ///</span>
+<span class="nv">ASSIGNED        = </span><span class="sr">/^\s*@?([$A-Za-z_][$\w\x7f-\uffff]*|[&#39;&quot;].*[&#39;&quot;])[^\n\S]*?[:=][^:=&gt;]/</span>
+
+<span class="nv">LINE_CONTINUER  = </span><span class="err">/// ^ \s* (?: , | \??\.(?![.\d]) | :: ) ///</span>
 
 <span class="nv">TRAILING_SPACES = </span><span class="sr">/\s+$/</span>
 
@@ -480,7 +498,7 @@ a division operator might.</p>
 <p>See: http://www.mozilla.org/js/language/js20-2002-04/rationale/syntax.html#regular-expressions</p>
 
 <p>Our list is shorter, due to sans-parentheses method calls.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">NOT_REGEX = </span><span class="p">[</span><span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span> <span class="s1">&#39;REGEX&#39;</span><span class="p">,</span> <span class="s1">&#39;BOOL&#39;</span><span class="p">,</span> <span class="s1">&#39;++&#39;</span><span class="p">,</span> <span class="s1">&#39;--&#39;</span><span class="p">,</span> <span class="s1">&#39;]&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-54">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-54">&#182;</a>               </div>               <p>If the previous token is not spaced, there are more preceding tokens that
-force a division parse:</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">NOT_SPACED_REGEX = </span><span class="nx">NOT_REGEX</span><span class="p">.</span><span class="nx">concat</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">,</span> <span class="s1">&#39;THIS&#39;</span><span class="p">,</span> <span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;STRING&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-55">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-55">&#182;</a>               </div>               <p>Tokens which could legitimately be invoked or indexed. A opening
+force a division parse:</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">NOT_SPACED_REGEX = </span><span class="nx">NOT_REGEX</span><span class="p">.</span><span class="nx">concat</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">,</span> <span class="s1">&#39;THIS&#39;</span><span class="p">,</span> <span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;STRING&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-55">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-55">&#182;</a>               </div>               <p>Tokens which could legitimately be invoked or indexed. An opening
 parentheses or bracket following these tokens will be recorded as the start
 of a function invocation or indexing operation.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CALLABLE  = </span><span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s1">&#39;REGEX&#39;</span><span class="p">,</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span> <span class="s1">&#39;]&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">,</span> <span class="s1">&#39;?&#39;</span><span class="p">,</span> <span class="s1">&#39;::&#39;</span><span class="p">,</span> <span class="s1">&#39;@&#39;</span><span class="p">,</span> <span class="s1">&#39;THIS&#39;</span><span class="p">,</span> <span class="s1">&#39;SUPER&#39;</span><span class="p">]</span>
 <span class="nv">INDEXABLE = </span><span class="nx">CALLABLE</span><span class="p">.</span><span class="nx">concat</span> <span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span> <span class="s1">&#39;BOOL&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-56">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-56">&#182;</a>               </div>               <p>Tokens that, when immediately preceding a <code>WHEN</code>, indicate that the <code>WHEN</code>

documentation/docs/optparse.html

@@ -13,7 +13,7 @@ option) list, and all subsequent arguments are left unparsed.</p>             </
 
 <p>Along with an an optional banner for the usage help.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">rules</span><span class="p">,</span> <span class="nx">@banner</span><span class="p">)</span> <span class="o">-&gt;</span>
     <span class="vi">@rules = </span><span class="nx">buildRules</span> <span class="nx">rules</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</a>               </div>               <p>Parse the list of arguments, populating an <code>options</code> object with all of the
-specified options, and returning it. <code>options.arguments</code> will be an array
+specified options, and return it. <code>options.arguments</code> will be an array
 containing the remaining non-option arguments. <code>options.literals</code> will be
 an array of options that are meant to be passed through directly to the
 executing script. This is a simpler API than many option parsers that allow
@@ -39,7 +39,7 @@ for interpreting the options object.</p>             </td>             <td class
         <span class="k">break</span>
     <span class="nx">options</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>Return the help text for this <strong>OptionParser</strong>, listing and describing all
 of the valid options, for <code>--help</code> and such.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">help</span><span class="o">:</span> <span class="o">-&gt;</span>
-    <span class="nv">lines = </span><span class="p">[</span><span class="s1">&#39;Available options:&#39;</span><span class="p">]</span>
+    <span class="nv">lines = </span><span class="p">[]</span>
     <span class="nx">lines</span><span class="p">.</span><span class="nx">unshift</span> <span class="s2">&quot;#{@banner}\n&quot;</span> <span class="k">if</span> <span class="nx">@banner</span>
     <span class="k">for</span> <span class="nx">rule</span> <span class="k">in</span> <span class="nx">@rules</span>
       <span class="nv">spaces  = </span><span class="mi">15</span> <span class="o">-</span> <span class="nx">rule</span><span class="p">.</span><span class="nx">longFlag</span><span class="p">.</span><span class="nx">length</span>

documentation/docs/repl.html

@@ -4,21 +4,87 @@ Using it looks like this:</p>
 
 <pre><code>coffee&gt; console.log "#{num} bottles of beer" for num in [99..1]
 </code></pre>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-2">&#182;</a>               </div>               <p>Require the <strong>coffee-script</strong> module to get access to the compiler.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">CoffeeScript = </span><span class="nx">require</span> <span class="s1">&#39;./coffee-script&#39;</span>
-<span class="nv">helpers      = </span><span class="nx">require</span> <span class="s1">&#39;./helpers&#39;</span>
-<span class="nv">readline     = </span><span class="nx">require</span> <span class="s1">&#39;readline&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</a>               </div>               <p>Start by opening up <strong>stdio</strong>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">stdio = </span><span class="nx">process</span><span class="p">.</span><span class="nx">openStdin</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>Log an error.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">error = </span><span class="p">(</span><span class="nx">err</span><span class="p">)</span> <span class="o">-&gt;</span>
-  <span class="nx">stdio</span><span class="p">.</span><span class="nx">write</span> <span class="p">(</span><span class="nx">err</span><span class="p">.</span><span class="nx">stack</span> <span class="o">or</span> <span class="nx">err</span><span class="p">.</span><span class="nx">toString</span><span class="p">())</span> <span class="o">+</span> <span class="s1">&#39;\n\n&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-5">&#182;</a>               </div>               <p>Quick alias for quitting the REPL.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">helpers</span><span class="p">.</span><span class="nx">extend</span> <span class="nx">global</span><span class="p">,</span> <span class="nx">quit</span><span class="o">:</span> <span class="o">-&gt;</span> <span class="nx">process</span><span class="p">.</span><span class="nx">exit</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-6">&#182;</a>               </div>               <p>The main REPL function. <strong>run</strong> is called every time a line of code is entered.
+<span class="nv">readline     = </span><span class="nx">require</span> <span class="s1">&#39;readline&#39;</span>
+<span class="p">{</span><span class="nx">inspect</span><span class="p">}</span>    <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;util&#39;</span>
+<span class="p">{</span><span class="nx">Script</span><span class="p">}</span>     <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;vm&#39;</span>
+<span class="nv">Module       = </span><span class="nx">require</span> <span class="s1">&#39;module&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</a>               </div>               <p>REPL Setup</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>Config</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">REPL_PROMPT = </span><span class="s1">&#39;coffee&gt; &#39;</span>
+<span class="nv">REPL_PROMPT_CONTINUATION = </span><span class="s1">&#39;......&gt; &#39;</span>
+<span class="nv">enableColours = </span><span class="kc">no</span>
+<span class="nx">unless</span> <span class="nx">process</span><span class="p">.</span><span class="nx">platform</span> <span class="o">is</span> <span class="s1">&#39;win32&#39;</span>
+  <span class="nv">enableColours = </span><span class="o">not</span> <span class="nx">process</span><span class="p">.</span><span class="nx">env</span><span class="p">.</span><span class="nx">NODE_DISABLE_COLORS</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-5">&#182;</a>               </div>               <p>Start by opening up <code>stdin</code> and <code>stdout</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">stdin = </span><span class="nx">process</span><span class="p">.</span><span class="nx">openStdin</span><span class="p">()</span>
+<span class="nv">stdout = </span><span class="nx">process</span><span class="p">.</span><span class="nx">stdout</span></pre></div>             </td>           </tr>                               <tr id="section-6">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-6">&#182;</a>               </div>               <p>Log an error.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">error = </span><span class="p">(</span><span class="nx">err</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">stdout</span><span class="p">.</span><span class="nx">write</span> <span class="p">(</span><span class="nx">err</span><span class="p">.</span><span class="nx">stack</span> <span class="o">or</span> <span class="nx">err</span><span class="p">.</span><span class="nx">toString</span><span class="p">())</span> <span class="o">+</span> <span class="s1">&#39;\n\n&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-7">&#182;</a>               </div>               <p>The current backlog of multi-line code.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">backlog = </span><span class="s1">&#39;&#39;</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-8">&#182;</a>               </div>               <p>The REPL context; must be visible outside <code>run</code> to allow for tab completion</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">sandbox = </span><span class="nx">Script</span><span class="p">.</span><span class="nx">createContext</span><span class="p">()</span>
+<span class="nv">nonContextGlobals = </span><span class="p">[</span>
+  <span class="s1">&#39;Buffer&#39;</span><span class="p">,</span> <span class="s1">&#39;console&#39;</span><span class="p">,</span> <span class="s1">&#39;process&#39;</span>
+  <span class="s1">&#39;setInterval&#39;</span><span class="p">,</span> <span class="s1">&#39;clearInterval&#39;</span>
+  <span class="s1">&#39;setTimeout&#39;</span><span class="p">,</span> <span class="s1">&#39;clearTimeout&#39;</span>
+<span class="p">]</span>
+<span class="nx">sandbox</span><span class="p">[</span><span class="nx">g</span><span class="p">]</span> <span class="o">=</span> <span class="nx">global</span><span class="p">[</span><span class="nx">g</span><span class="p">]</span> <span class="k">for</span> <span class="nx">g</span> <span class="k">in</span> <span class="nx">nonContextGlobals</span>
+<span class="nv">sandbox.global = sandbox.root = sandbox.GLOBAL = </span><span class="nx">sandbox</span></pre></div>             </td>           </tr>                               <tr id="section-9">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-9">&#182;</a>               </div>               <p>The main REPL function. <strong>run</strong> is called every time a line of code is entered.
 Attempt to evaluate the command. If there's an exception, print it out instead
 of exiting.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">run = </span><span class="p">(</span><span class="nx">buffer</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="k">if</span> <span class="o">!</span><span class="nx">buffer</span><span class="p">.</span><span class="nx">toString</span><span class="p">().</span><span class="nx">trim</span><span class="p">()</span> <span class="o">and</span> <span class="o">!</span><span class="nx">backlog</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">prompt</span><span class="p">()</span>
+    <span class="k">return</span>
+  <span class="nv">code = </span><span class="nx">backlog</span> <span class="o">+=</span> <span class="nx">buffer</span>
+  <span class="k">if</span> <span class="nx">code</span><span class="p">[</span><span class="nx">code</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;\\&#39;</span>
+    <span class="nv">backlog = </span><span class="s2">&quot;#{backlog[...-1]}\n&quot;</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">setPrompt</span> <span class="nx">REPL_PROMPT_CONTINUATION</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">prompt</span><span class="p">()</span>
+    <span class="k">return</span>
+  <span class="nx">repl</span><span class="p">.</span><span class="nx">setPrompt</span> <span class="nx">REPL_PROMPT</span>
+  <span class="nv">backlog = </span><span class="s1">&#39;&#39;</span>
   <span class="k">try</span>
-    <span class="nv">val = </span><span class="nx">CoffeeScript</span><span class="p">.</span><span class="nb">eval</span> <span class="nx">buffer</span><span class="p">.</span><span class="nx">toString</span><span class="p">(),</span> <span class="nx">bare</span><span class="o">:</span> <span class="kc">on</span><span class="p">,</span> <span class="nx">globals</span><span class="o">:</span> <span class="kc">on</span><span class="p">,</span> <span class="nx">fileName</span><span class="o">:</span> <span class="s1">&#39;repl&#39;</span>
-    <span class="nx">console</span><span class="p">.</span><span class="nx">log</span> <span class="nx">val</span> <span class="k">if</span> <span class="nx">val</span> <span class="o">isnt</span> <span class="kc">undefined</span>
+    <span class="nv">_ = </span><span class="nx">sandbox</span><span class="p">.</span><span class="nx">_</span>
+    <span class="nv">returnValue = </span><span class="nx">CoffeeScript</span><span class="p">.</span><span class="nb">eval</span> <span class="s2">&quot;_=(#{code}\n)&quot;</span><span class="p">,</span> <span class="p">{</span>
+      <span class="nx">sandbox</span><span class="p">,</span>
+      <span class="nx">filename</span><span class="o">:</span> <span class="s1">&#39;repl&#39;</span>
+      <span class="nx">modulename</span><span class="o">:</span> <span class="s1">&#39;repl&#39;</span>
+    <span class="p">}</span>
+    <span class="k">if</span> <span class="nx">returnValue</span> <span class="o">is</span> <span class="kc">undefined</span>
+      <span class="nv">sandbox._ = </span><span class="nx">_</span>
+    <span class="k">else</span>
+      <span class="nx">process</span><span class="p">.</span><span class="nx">stdout</span><span class="p">.</span><span class="nx">write</span> <span class="nx">inspect</span><span class="p">(</span><span class="nx">returnValue</span><span class="p">,</span> <span class="kc">no</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">enableColours</span><span class="p">)</span> <span class="o">+</span> <span class="s1">&#39;\n&#39;</span>
   <span class="k">catch</span> <span class="nx">err</span>
     <span class="nx">error</span> <span class="nx">err</span>
-  <span class="nx">repl</span><span class="p">.</span><span class="nx">prompt</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-7">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-7">&#182;</a>               </div>               <p>Make sure that uncaught exceptions don't kill the REPL.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">process</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;uncaughtException&#39;</span><span class="p">,</span> <span class="nx">error</span></pre></div>             </td>           </tr>                               <tr id="section-8">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-8">&#182;</a>               </div>               <p>Create the REPL by listening to <strong>stdin</strong>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">repl = </span><span class="nx">readline</span><span class="p">.</span><span class="nx">createInterface</span> <span class="nx">stdio</span>
-<span class="nx">repl</span><span class="p">.</span><span class="nx">setPrompt</span> <span class="s1">&#39;coffee&gt; &#39;</span>
-<span class="nx">stdio</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;data&#39;</span><span class="p">,</span>   <span class="p">(</span><span class="nx">buffer</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">repl</span><span class="p">.</span><span class="nx">write</span> <span class="nx">buffer</span>
-<span class="nx">repl</span><span class="p">.</span><span class="kc">on</span>  <span class="s1">&#39;close&#39;</span><span class="p">,</span>  <span class="o">-&gt;</span> <span class="nx">stdio</span><span class="p">.</span><span class="nx">destroy</span><span class="p">()</span>
-<span class="nx">repl</span><span class="p">.</span><span class="kc">on</span>  <span class="s1">&#39;line&#39;</span><span class="p">,</span>   <span class="nx">run</span>
+  <span class="nx">repl</span><span class="p">.</span><span class="nx">prompt</span><span class="p">()</span></pre></div>             </td>           </tr>                               <tr id="section-10">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-10">&#182;</a>               </div>               <h1>Autocompletion</h1>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-11">&#182;</a>               </div>               <p>Regexes to match complete-able bits of text.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">ACCESSOR  = </span><span class="sr">/\s*([\w\.]+)(?:\.(\w*))$/</span>
+<span class="nv">SIMPLEVAR = </span><span class="sr">/\s*(\w*)$/i</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#182;</a>               </div>               <p>Returns a list of completions, and the completed text.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">autocomplete = </span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="nx">completeAttribute</span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">or</span> <span class="nx">completeVariable</span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">or</span> <span class="p">[[],</span> <span class="nx">text</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-13">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-13">&#182;</a>               </div>               <p>Attempt to autocomplete a chained dotted attribute: <code>one.two.three</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">completeAttribute = </span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="k">if</span> <span class="nv">match = </span><span class="nx">text</span><span class="p">.</span><span class="nx">match</span> <span class="nx">ACCESSOR</span>
+    <span class="p">[</span><span class="nx">all</span><span class="p">,</span> <span class="nx">obj</span><span class="p">,</span> <span class="nx">prefix</span><span class="p">]</span> <span class="o">=</span> <span class="nx">match</span>
+    <span class="k">try</span>
+      <span class="nv">val = </span><span class="nx">Script</span><span class="p">.</span><span class="nx">runInContext</span> <span class="nx">obj</span><span class="p">,</span> <span class="nx">sandbox</span>
+    <span class="k">catch</span> <span class="nx">error</span>
+      <span class="k">return</span>
+    <span class="nv">completions = </span><span class="nx">getCompletions</span> <span class="nx">prefix</span><span class="p">,</span> <span class="nb">Object</span><span class="p">.</span><span class="nx">getOwnPropertyNames</span> <span class="nx">val</span>
+    <span class="p">[</span><span class="nx">completions</span><span class="p">,</span> <span class="nx">prefix</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-14">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-14">&#182;</a>               </div>               <p>Attempt to autocomplete an in-scope free variable: <code>one</code>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">completeVariable = </span><span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="k">if</span> <span class="nv">free = </span><span class="p">(</span><span class="nx">text</span><span class="p">.</span><span class="nx">match</span> <span class="nx">SIMPLEVAR</span><span class="p">)</span><span class="o">?</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
+    <span class="nv">vars = </span><span class="nx">Script</span><span class="p">.</span><span class="nx">runInContext</span> <span class="s1">&#39;Object.getOwnPropertyNames(this)&#39;</span><span class="p">,</span> <span class="nx">sandbox</span>
+    <span class="nv">possibilities = </span><span class="nx">vars</span><span class="p">.</span><span class="nx">concat</span> <span class="nx">CoffeeScript</span><span class="p">.</span><span class="nx">RESERVED</span>
+    <span class="nv">completions = </span><span class="nx">getCompletions</span> <span class="nx">free</span><span class="p">,</span> <span class="nx">possibilities</span>
+    <span class="p">[</span><span class="nx">completions</span><span class="p">,</span> <span class="nx">free</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-15">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-15">&#182;</a>               </div>               <p>Return elements of candidates for which <code>prefix</code> is a prefix.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">getCompletions = </span><span class="p">(</span><span class="nx">prefix</span><span class="p">,</span> <span class="nx">candidates</span><span class="p">)</span> <span class="o">-&gt;</span>
+  <span class="p">(</span><span class="nx">el</span> <span class="k">for</span> <span class="nx">el</span> <span class="k">in</span> <span class="nx">candidates</span> <span class="k">when</span> <span class="nx">el</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">prefix</span><span class="p">)</span> <span class="o">is</span> <span class="mi">0</span><span class="p">)</span></pre></div>             </td>           </tr>                               <tr id="section-16">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-16">&#182;</a>               </div>               <p>Make sure that uncaught exceptions don't kill the REPL.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nx">process</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;uncaughtException&#39;</span><span class="p">,</span> <span class="nx">error</span></pre></div>             </td>           </tr>                               <tr id="section-17">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-17">&#182;</a>               </div>               <p>Create the REPL by listening to <strong>stdin</strong>.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="k">if</span> <span class="nx">readline</span><span class="p">.</span><span class="nx">createInterface</span><span class="p">.</span><span class="nx">length</span> <span class="o">&lt;</span> <span class="mi">3</span>
+  <span class="nv">repl = </span><span class="nx">readline</span><span class="p">.</span><span class="nx">createInterface</span> <span class="nx">stdin</span><span class="p">,</span> <span class="nx">autocomplete</span>
+  <span class="nx">stdin</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;data&#39;</span><span class="p">,</span> <span class="p">(</span><span class="nx">buffer</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">repl</span><span class="p">.</span><span class="nx">write</span> <span class="nx">buffer</span>
+<span class="k">else</span>
+  <span class="nv">repl = </span><span class="nx">readline</span><span class="p">.</span><span class="nx">createInterface</span> <span class="nx">stdin</span><span class="p">,</span> <span class="nx">stdout</span><span class="p">,</span> <span class="nx">autocomplete</span>
+
+<span class="nx">repl</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;attemptClose&#39;</span><span class="p">,</span> <span class="o">-&gt;</span>
+  <span class="k">if</span> <span class="nx">backlog</span>
+    <span class="nv">backlog = </span><span class="s1">&#39;&#39;</span>
+    <span class="nx">process</span><span class="p">.</span><span class="nx">stdout</span><span class="p">.</span><span class="nx">write</span> <span class="s1">&#39;\n&#39;</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">setPrompt</span> <span class="nx">REPL_PROMPT</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">prompt</span><span class="p">()</span>
+  <span class="k">else</span>
+    <span class="nx">repl</span><span class="p">.</span><span class="nx">close</span><span class="p">()</span>
+
+<span class="nx">repl</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;close&#39;</span><span class="p">,</span> <span class="o">-&gt;</span>
+  <span class="nx">process</span><span class="p">.</span><span class="nx">stdout</span><span class="p">.</span><span class="nx">write</span> <span class="s1">&#39;\n&#39;</span>
+  <span class="nx">stdin</span><span class="p">.</span><span class="nx">destroy</span><span class="p">()</span>
+
+<span class="nx">repl</span><span class="p">.</span><span class="kc">on</span> <span class="s1">&#39;line&#39;</span><span class="p">,</span> <span class="nx">run</span>
+
+<span class="nx">repl</span><span class="p">.</span><span class="nx">setPrompt</span> <span class="nx">REPL_PROMPT</span>
 <span class="nx">repl</span><span class="p">.</span><span class="nx">prompt</span><span class="p">()</span>
 
 </pre></div>             </td>           </tr>                </tbody>     </table>   </div> </body> </html> 

documentation/docs/rewriter.html

@@ -78,7 +78,10 @@ Insert the missing braces here, so that the parser doesn't have to.</p>
         <span class="o">not</span> <span class="p">(</span><span class="nx">two</span><span class="o">?</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;:&#39;</span> <span class="o">or</span> <span class="nx">one</span><span class="o">?</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;@&#39;</span> <span class="o">and</span> <span class="nx">three</span><span class="o">?</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;:&#39;</span><span class="p">))</span> <span class="o">or</span>
         <span class="p">(</span><span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;,&#39;</span> <span class="o">and</span> <span class="nx">one</span> <span class="o">and</span>
           <span class="nx">one</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">not</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;IDENTIFIER&#39;</span><span class="p">,</span> <span class="s1">&#39;NUMBER&#39;</span><span class="p">,</span> <span class="s1">&#39;STRING&#39;</span><span class="p">,</span> <span class="s1">&#39;@&#39;</span><span class="p">,</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">])</span>
-    <span class="nv">action = </span><span class="p">(</span><span class="nx">token</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;}&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]]</span>
+    <span class="nv">action = </span><span class="p">(</span><span class="nx">token</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">-&gt;</span>
+      <span class="nv">tok = </span><span class="p">[</span><span class="s1">&#39;}&#39;</span><span class="p">,</span> <span class="s1">&#39;}&#39;</span><span class="p">,</span> <span class="nx">token</span><span class="p">[</span><span class="mi">2</span><span class="p">]]</span>
+      <span class="nv">tok.generated = </span><span class="kc">yes</span>
+      <span class="nx">@tokens</span><span class="p">.</span><span class="nx">splice</span> <span class="nx">i</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">tok</span>
     <span class="nx">@scanTokens</span> <span class="p">(</span><span class="nx">token</span><span class="p">,</span> <span class="nx">i</span><span class="p">,</span> <span class="nx">tokens</span><span class="p">)</span> <span class="o">-&gt;</span>
       <span class="k">if</span> <span class="p">(</span><span class="nv">tag = </span><span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span> <span class="k">in</span> <span class="nx">EXPRESSION_START</span>
         <span class="nx">stack</span><span class="p">.</span><span class="nx">push</span> <span class="p">[(</span><span class="k">if</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;INDENT&#39;</span> <span class="o">and</span> <span class="nx">@tag</span><span class="p">(</span><span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">is</span> <span class="s1">&#39;{&#39;</span> <span class="k">then</span> <span class="s1">&#39;{&#39;</span> <span class="k">else</span> <span class="nx">tag</span><span class="p">),</span> <span class="nx">i</span><span class="p">]</span>
@@ -108,12 +111,14 @@ deal with them.</p>             </td>             <td class="code">
       <span class="nv">tag     = </span><span class="nx">token</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
       <span class="nv">noCall  = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;CLASS&#39;</span><span class="p">,</span> <span class="s1">&#39;IF&#39;</span><span class="p">]</span>
       <span class="p">[</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">current</span><span class="p">,</span> <span class="nx">next</span><span class="p">]</span> <span class="o">=</span> <span class="nx">tokens</span><span class="p">[</span><span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span> <span class="p">..</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span>
-      <span class="nv">callObject = </span><span class="o">not</span> <span class="nx">noCall</span> <span class="o">and</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;INDENT&#39;</span> <span class="o">and</span>
-                   <span class="nx">next</span> <span class="o">and</span> <span class="nx">next</span><span class="p">.</span><span class="nx">generated</span> <span class="o">and</span> <span class="nx">next</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;{&#39;</span> <span class="o">and</span>
-                   <span class="nx">prev</span> <span class="o">and</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">in</span> <span class="nx">IMPLICIT_FUNC</span>
-      <span class="nv">seenSingle = </span><span class="kc">no</span>
-      <span class="nv">noCall     = </span><span class="kc">no</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</span> <span class="nx">LINEBREAKS</span>
-      <span class="nv">token.call = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">prev</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">prev</span><span class="p">.</span><span class="nx">spaced</span> <span class="o">and</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;?&#39;</span>
+      <span class="nv">callObject  = </span><span class="o">not</span> <span class="nx">noCall</span> <span class="o">and</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;INDENT&#39;</span> <span class="o">and</span>
+                    <span class="nx">next</span> <span class="o">and</span> <span class="nx">next</span><span class="p">.</span><span class="nx">generated</span> <span class="o">and</span> <span class="nx">next</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;{&#39;</span> <span class="o">and</span>
+                    <span class="nx">prev</span> <span class="o">and</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">in</span> <span class="nx">IMPLICIT_FUNC</span>
+      <span class="nv">seenSingle  = </span><span class="kc">no</span>
+      <span class="nv">seenControl = </span><span class="kc">no</span>
+      <span class="nv">noCall      = </span><span class="kc">no</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</span> <span class="nx">LINEBREAKS</span>
+      <span class="nv">token.call  = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">prev</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">prev</span><span class="p">.</span><span class="nx">spaced</span> <span class="o">and</span> <span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;?&#39;</span>
+      <span class="k">return</span> <span class="mi">1</span> <span class="k">if</span> <span class="nx">token</span><span class="p">.</span><span class="nx">fromThen</span>
       <span class="k">return</span> <span class="mi">1</span> <span class="nx">unless</span> <span class="nx">callObject</span> <span class="o">or</span>
         <span class="nx">prev</span><span class="o">?</span><span class="p">.</span><span class="nx">spaced</span> <span class="o">and</span> <span class="p">(</span><span class="nx">prev</span><span class="p">.</span><span class="nx">call</span> <span class="o">or</span> <span class="nx">prev</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="k">in</span> <span class="nx">IMPLICIT_FUNC</span><span class="p">)</span> <span class="o">and</span>
         <span class="p">(</span><span class="nx">tag</span> <span class="k">in</span> <span class="nx">IMPLICIT_CALL</span> <span class="o">or</span> <span class="o">not</span> <span class="p">(</span><span class="nx">token</span><span class="p">.</span><span class="nx">spaced</span> <span class="o">or</span> <span class="nx">token</span><span class="p">.</span><span class="nx">newLine</span><span class="p">)</span> <span class="o">and</span> <span class="nx">tag</span> <span class="k">in</span> <span class="nx">IMPLICIT_UNSPACED_CALL</span><span class="p">)</span>
@@ -121,9 +126,11 @@ deal with them.</p>             </td>             <td class="code">
       <span class="nx">@detectEnd</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="p">(</span><span class="nx">token</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="o">-&gt;</span>
         <span class="p">[</span><span class="nx">tag</span><span class="p">]</span> <span class="o">=</span> <span class="nx">token</span>
         <span class="k">return</span> <span class="kc">yes</span> <span class="k">if</span> <span class="o">not</span> <span class="nx">seenSingle</span> <span class="o">and</span> <span class="nx">token</span><span class="p">.</span><span class="nx">fromThen</span>
-        <span class="nv">seenSingle = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;IF&#39;</span><span class="p">,</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">]</span>
+        <span class="nv">seenSingle  = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;IF&#39;</span><span class="p">,</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;CATCH&#39;</span><span class="p">,</span> <span class="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">]</span>
+        <span class="nv">seenControl = </span><span class="kc">yes</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;IF&#39;</span><span class="p">,</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;SWITCH&#39;</span><span class="p">,</span> <span class="s1">&#39;TRY&#39;</span><span class="p">]</span>
         <span class="k">return</span> <span class="kc">yes</span> <span class="k">if</span> <span class="nx">tag</span> <span class="k">in</span> <span class="p">[</span><span class="s1">&#39;.&#39;</span><span class="p">,</span> <span class="s1">&#39;?.&#39;</span><span class="p">,</span> <span class="s1">&#39;::&#39;</span><span class="p">]</span> <span class="o">and</span> <span class="nx">@tag</span><span class="p">(</span><span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">is</span> <span class="s1">&#39;OUTDENT&#39;</span>
-        <span class="o">not</span> <span class="nx">token</span><span class="p">.</span><span class="nx">generated</span> <span class="o">and</span> <span class="nx">@tag</span><span class="p">(</span><span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">isnt</span> <span class="s1">&#39;,&#39;</span> <span class="o">and</span> <span class="nx">tag</span> <span class="k">in</span> <span class="nx">IMPLICIT_END</span> <span class="o">and</span>
+        <span class="o">not</span> <span class="nx">token</span><span class="p">.</span><span class="nx">generated</span> <span class="o">and</span> <span class="nx">@tag</span><span class="p">(</span><span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">isnt</span> <span class="s1">&#39;,&#39;</span> <span class="o">and</span> <span class="p">(</span><span class="nx">tag</span> <span class="k">in</span> <span class="nx">IMPLICIT_END</span> <span class="o">or</span>
+        <span class="p">(</span><span class="nx">tag</span> <span class="o">is</span> <span class="s1">&#39;INDENT&#39;</span> <span class="o">and</span> <span class="o">not</span> <span class="nx">seenControl</span><span class="p">))</span> <span class="o">and</span>
         <span class="p">(</span><span class="nx">tag</span> <span class="o">isnt</span> <span class="s1">&#39;INDENT&#39;</span> <span class="o">or</span>
          <span class="p">(</span><span class="nx">@tag</span><span class="p">(</span><span class="nx">i</span> <span class="o">-</span> <span class="mi">2</span><span class="p">)</span> <span class="o">isnt</span> <span class="s1">&#39;CLASS&#39;</span> <span class="o">and</span> <span class="nx">@tag</span><span class="p">(</span><span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">not</span> <span class="k">in</span> <span class="nx">IMPLICIT_BLOCK</span> <span class="o">and</span>
           <span class="o">not</span> <span class="p">((</span><span class="nv">post = </span><span class="nx">@tokens</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">])</span> <span class="o">and</span> <span class="nx">post</span><span class="p">.</span><span class="nx">generated</span> <span class="o">and</span> <span class="nx">post</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">is</span> <span class="s1">&#39;{&#39;</span><span class="p">)))</span>
@@ -244,7 +251,7 @@ look things up from either end.</p>             </td>             <td class="cod
   <span class="s1">&#39;@&#39;</span><span class="p">,</span> <span class="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;[&#39;</span><span class="p">,</span> <span class="s1">&#39;(&#39;</span><span class="p">,</span> <span class="s1">&#39;{&#39;</span><span class="p">,</span> <span class="s1">&#39;--&#39;</span><span class="p">,</span> <span class="s1">&#39;++&#39;</span>
 <span class="p">]</span>
 
-<span class="nv">IMPLICIT_UNSPACED_CALL = </span><span class="p">[</span><span class="s1">&#39;+&#39;</span><span class="p">,</span> <span class="s1">&#39;-&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-25">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-25">&#182;</a>               </div>               <p>Tokens indicating that the implicit call must enclose a block of expressions.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_BLOCK   = </span><span class="p">[</span><span class="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;{&#39;</span><span class="p">,</span> <span class="s1">&#39;[&#39;</span><span class="p">,</span> <span class="s1">&#39;,&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#182;</a>               </div>               <p>Tokens that always mark the end of an implicit call for single-liners.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_END     = </span><span class="p">[</span><span class="s1">&#39;POST_IF&#39;</span><span class="p">,</span> <span class="s1">&#39;FOR&#39;</span><span class="p">,</span> <span class="s1">&#39;WHILE&#39;</span><span class="p">,</span> <span class="s1">&#39;UNTIL&#39;</span><span class="p">,</span> <span class="s1">&#39;WHEN&#39;</span><span class="p">,</span> <span class="s1">&#39;BY&#39;</span><span class="p">,</span> <span class="s1">&#39;LOOP&#39;</span><span class="p">,</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;INDENT&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-27">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-27">&#182;</a>               </div>               <p>Single-line flavors of block expressions that have unclosed endings.
+<span class="nv">IMPLICIT_UNSPACED_CALL = </span><span class="p">[</span><span class="s1">&#39;+&#39;</span><span class="p">,</span> <span class="s1">&#39;-&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-25">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-25">&#182;</a>               </div>               <p>Tokens indicating that the implicit call must enclose a block of expressions.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_BLOCK   = </span><span class="p">[</span><span class="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;{&#39;</span><span class="p">,</span> <span class="s1">&#39;[&#39;</span><span class="p">,</span> <span class="s1">&#39;,&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-26">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-26">&#182;</a>               </div>               <p>Tokens that always mark the end of an implicit call for single-liners.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">IMPLICIT_END     = </span><span class="p">[</span><span class="s1">&#39;POST_IF&#39;</span><span class="p">,</span> <span class="s1">&#39;FOR&#39;</span><span class="p">,</span> <span class="s1">&#39;WHILE&#39;</span><span class="p">,</span> <span class="s1">&#39;UNTIL&#39;</span><span class="p">,</span> <span class="s1">&#39;WHEN&#39;</span><span class="p">,</span> <span class="s1">&#39;BY&#39;</span><span class="p">,</span> <span class="s1">&#39;LOOP&#39;</span><span class="p">,</span> <span class="s1">&#39;TERMINATOR&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-27">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-27">&#182;</a>               </div>               <p>Single-line flavors of block expressions that have unclosed endings.
 The grammar can't disambiguate them, so we insert the implicit indentation.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">SINGLE_LINERS    = </span><span class="p">[</span><span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;-&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;=&gt;&#39;</span><span class="p">,</span> <span class="s1">&#39;TRY&#39;</span><span class="p">,</span> <span class="s1">&#39;FINALLY&#39;</span><span class="p">,</span> <span class="s1">&#39;THEN&#39;</span><span class="p">]</span>
 <span class="nv">SINGLE_CLOSERS   = </span><span class="p">[</span><span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;CATCH&#39;</span><span class="p">,</span> <span class="s1">&#39;FINALLY&#39;</span><span class="p">,</span> <span class="s1">&#39;ELSE&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">,</span> <span class="s1">&#39;LEADING_WHEN&#39;</span><span class="p">]</span></pre></div>             </td>           </tr>                               <tr id="section-28">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-28">&#182;</a>               </div>               <p>Tokens that end a line.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="nv">LINEBREAKS       = </span><span class="p">[</span><span class="s1">&#39;TERMINATOR&#39;</span><span class="p">,</span> <span class="s1">&#39;INDENT&#39;</span><span class="p">,</span> <span class="s1">&#39;OUTDENT&#39;</span><span class="p">]</span>
 

documentation/docs/scope.html

@@ -6,9 +6,9 @@ variables are new and need to be declared with <code>var</code>, and which are s
 with the outside.</p>             </td>             <td class="code">               <div class="highlight"><pre></pre></div>             </td>           </tr>                               <tr id="section-2">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-2">&#182;</a>               </div>               <p>Import the helpers we plan to use.</p>             </td>             <td class="code">               <div class="highlight"><pre><span class="p">{</span><span class="nx">extend</span><span class="p">,</span> <span class="nx">last</span><span class="p">}</span> <span class="o">=</span> <span class="nx">require</span> <span class="s1">&#39;./helpers&#39;</span>
 
 <span class="nv">exports.Scope = </span><span class="nx">class</span> <span class="nx">Scope</span></pre></div>             </td>           </tr>                               <tr id="section-3">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-3">&#182;</a>               </div>               <p>The top-level <strong>Scope</strong> object.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">@root</span><span class="o">:</span> <span class="kc">null</span></pre></div>             </td>           </tr>                               <tr id="section-4">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-4">&#182;</a>               </div>               <p>Initialize a scope with its parent, for lookups up the chain,
-as well as a reference to the <strong>Expressions</strong> node is belongs to, which is
+as well as a reference to the <strong>Block</strong> node it belongs to, which is
 where it should declare its variables, and a reference to the function that
-it wraps.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">constructor</span><span class="o">:</span><span class="p">(</span><span class="nx">@parent</span><span class="p">,</span> <span class="nx">@expressions</span><span class="p">,</span> <span class="nx">@method</span><span class="p">)</span> <span class="o">-&gt;</span>
+it wraps.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">constructor</span><span class="o">:</span> <span class="p">(</span><span class="nx">@parent</span><span class="p">,</span> <span class="nx">@expressions</span><span class="p">,</span> <span class="nx">@method</span><span class="p">)</span> <span class="o">-&gt;</span>
     <span class="vi">@variables = </span><span class="p">[{</span><span class="nx">name</span><span class="o">:</span> <span class="s1">&#39;arguments&#39;</span><span class="p">,</span> <span class="nx">type</span><span class="o">:</span> <span class="s1">&#39;arguments&#39;</span><span class="p">}]</span>
     <span class="vi">@positions = </span><span class="p">{}</span>
     <span class="nv">Scope.root = </span><span class="k">this</span> <span class="nx">unless</span> <span class="nx">@parent</span></pre></div>             </td>           </tr>                               <tr id="section-5">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-5">&#182;</a>               </div>               <p>Adds a new variable or overrides an existing one.</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">add</span><span class="o">:</span> <span class="p">(</span><span class="nx">name</span><span class="p">,</span> <span class="nx">type</span><span class="p">,</span> <span class="nx">immediate</span><span class="p">)</span> <span class="o">-&gt;</span>
@@ -36,7 +36,7 @@ walks up to the root scope.</p>             </td>             <td class="code">
     <span class="kc">null</span></pre></div>             </td>           </tr>                               <tr id="section-11">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-11">&#182;</a>               </div>               <p>If we need to store an intermediate result, find an available name for a
 compiler-generated variable. <code>_var</code>, <code>_var2</code>, and so on...</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">freeVariable</span><span class="o">:</span> <span class="p">(</span><span class="nx">type</span><span class="p">)</span> <span class="o">-&gt;</span>
     <span class="nv">index = </span><span class="mi">0</span>
-    <span class="nx">index</span><span class="o">++</span> <span class="k">while</span> <span class="nx">@check</span><span class="p">((</span><span class="nv">temp = </span><span class="nx">@temporary</span> <span class="nx">type</span><span class="p">,</span> <span class="nx">index</span><span class="p">),</span> <span class="kc">true</span><span class="p">)</span>
+    <span class="nx">index</span><span class="o">++</span> <span class="k">while</span> <span class="nx">@check</span><span class="p">((</span><span class="nv">temp = </span><span class="nx">@temporary</span> <span class="nx">type</span><span class="p">,</span> <span class="nx">index</span><span class="p">))</span>
     <span class="nx">@add</span> <span class="nx">temp</span><span class="p">,</span> <span class="s1">&#39;var&#39;</span><span class="p">,</span> <span class="kc">yes</span>
     <span class="nx">temp</span></pre></div>             </td>           </tr>                               <tr id="section-12">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-12">&#182;</a>               </div>               <p>Ensure that an assignment is made at the top of this scope
 (or at the top-level scope, if requested).</p>             </td>             <td class="code">               <div class="highlight"><pre>  <span class="nx">assign</span><span class="o">:</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="o">-&gt;</span>

documentation/docs/underscore.html

@@ -1,5 +1,5 @@
 <!DOCTYPE html>  <html> <head>   <title>underscore.coffee</title>   <meta http-equiv="content-type" content="text/html; charset=UTF-8">   <link rel="stylesheet" media="all" href="docco.css" /> </head> <body>   <div id="container">     <div id="background"></div>          <table cellpadding="0" cellspacing="0">       <thead>         <tr>           <th class="docs">             <h1>               underscore.coffee             </h1>           </th>           <th class="code">           </th>         </tr>       </thead>       <tbody>                               <tr id="section-1">             <td class="docs">               <div class="pilwrap">                 <a class="pilcrow" href="#section-1">&#182;</a>               </div>               <p><strong>Underscore.coffee
-(c) 2010 Jeremy Ashkenas, DocumentCloud Inc.</strong>
+(c) 2011 Jeremy Ashkenas, DocumentCloud Inc.</strong>
 Underscore is freely distributable under the terms of the
 <a href="http://en.wikipedia.org/wiki/MIT_License">MIT license</a>.
 Portions of Underscore are inspired by or borrowed from

documentation/index.html.erb

@@ -80,10 +80,10 @@
           <div class="screenshadow bl"></div>
           <div class="screenshadow br"></div>
           <div id="repl_source_wrap">
-            <textarea id="repl_source" rows="100">alert "Hello CoffeeScript!"</textarea>
+            <textarea id="repl_source" rows="100" spellcheck="false">alert "Hello CoffeeScript!"</textarea>
           </div>
           <div id="repl_results_wrap"><pre id="repl_results"></pre></div>
-          <div class="minibutton dark run">Run</div>
+          <div class="minibutton dark run" title="Ctrl-Enter">Run</div>
           <br class="clear" />
         </div>
       </div>
@@ -131,7 +131,7 @@
 
     <p>
       <b>Latest Version:</b>
-      <a href="http://github.com/jashkenas/coffee-script/tarball/1.0.0">1.0.0</a>
+      <a href="http://github.com/jashkenas/coffee-script/tarball/1.1.2">1.1.2</a>
     </p>
 
     <h2>
@@ -166,17 +166,21 @@
     </p>
 
     <pre>
-npm install coffee-script</pre>
+npm install -g coffee-script</pre>
 
-  <p>
-    If you'd prefer to install the latest master version of CoffeeScript, you
-    can clone the CoffeeScript
-    <a href="http://github.com/jashkenas/coffee-script">source repository</a>
-    from GitHub, or download
-    <a href="http://github.com/jashkenas/coffee-script/tarball/master">the source</a> directly.
-    To install the CoffeeScript compiler system-wide
-    under <tt>/usr/local</tt>, open the directory and run:
-  </p>
+    <p>
+      (Leave off the <tt>-g</tt> if you don't wish to install globally.)
+    </p>
+    
+    <p>
+      If you'd prefer to install the latest master version of CoffeeScript, you
+      can clone the CoffeeScript
+      <a href="http://github.com/jashkenas/coffee-script">source repository</a>
+      from GitHub, or download
+      <a href="http://github.com/jashkenas/coffee-script/tarball/master">the source</a> directly.
+      To install the CoffeeScript compiler system-wide
+      under <tt>/usr/local</tt>, open the directory and run:
+    </p>
 
   <pre>
 sudo bin/cake install</pre>
@@ -185,7 +189,9 @@ sudo bin/cake install</pre>
       If installing on Ubuntu or Debian,
       <a href="http://opinionated-programmer.com/2010/12/installing-coffeescript-on-debian-or-ubuntu/">be
       careful not to use the existing out-of-date package</a>. If installing on
-      Windows, your best bet is probably to run Node.js under Cygwin.
+      Windows, your best bet is probably to run Node.js under Cygwin. If you'd
+      just like to experiment, you can try the 
+      <a href="https://github.com/alisey/CoffeeScript-Compiler-for-Windows">CoffeeScript Compiler For Windows</a>.
     </p>
 
     <p>
@@ -219,10 +225,11 @@ sudo bin/cake install</pre>
         </td>
       </tr>
       <tr>
-        <td><code>-j, --join</code></td>
+        <td><code>-j, --join [FILE]</code></td>
         <td>
           Before compiling, concatenate all scripts together in the order they
-          were passed. Useful for building large projects.
+          were passed, and write them into the specified file. 
+          Useful for building large projects.
         </td>
       </tr>
       <tr>
@@ -261,7 +268,7 @@ sudo bin/cake install</pre>
         <td><code>-e, --eval</code></td>
         <td>
           Compile and print a little snippet of CoffeeScript directly from the
-          command line. For example:<br /><tt>coffee -e "puts num for num in [10..1]"</tt>
+          command line. For example:<br /><tt>coffee -e "console.log num for num in [10..1]"</tt>
         </td>
       </tr>
       <tr>
@@ -304,7 +311,7 @@ Expressions
         <td><code>--nodejs</code></td>
         <td>
           The <tt>node</tt> executable has some useful options you can set,
-          such as<br /> <tt>--debug</tt> and <tt>--max-stack-size</tt>. Use this
+          such as<br /> <tt>--debug</tt>, <tt>--debug-brk</tt> and <tt>--max-stack-size</tt>. Use this
           flag to forward options directly to Node.js.
         </td>
       </tr>
@@ -326,7 +333,7 @@ Expressions
       </li>
       <li>
         Concatenate a list of files into a single script:<br />
-        <tt>coffee -o lib/ --join --compile src/*.coffee</tt>
+        <tt>coffee --join project.js --compile src/*.coffee</tt>
       </li>
       <li>
         Print out the compiled JS from a one-liner:<br />
@@ -362,8 +369,8 @@ Expressions
     <p>
       First, the basics: CoffeeScript uses significant whitespace to delimit blocks of code.
       You don't need to use semicolons <tt>;</tt> to terminate expressions,
-      ending the line will do just as well, (although semicolons can still
-      be used to fit multiple expressions onto a single line.)
+      ending the line will do just as well (although semicolons can still
+      be used to fit multiple expressions onto a single line).
       Instead of using curly braces
       <tt>{ }</tt> to surround blocks of code in <a href="#functions">functions</a>,
       <a href="#conditionals">if-statements</a>,
@@ -442,7 +449,7 @@ Expressions
       If you'd like to create top-level variables for other scripts to use,
       attach them as properties on <b>window</b>, or on the <b>exports</b>
       object in CommonJS. The <b>existential operator</b> (covered below), gives you a
-      reliable way to figure out where to add them, if you're targeting both
+      reliable way to figure out where to add them; if you're targeting both
       CommonJS and the browser: <tt>exports ? this</tt>
     </p>
 
@@ -479,11 +486,13 @@ Expressions
       over arrays, objects, and ranges. Comprehensions replace (and compile into)
       <b>for</b> loops, with optional guard clauses and the value of the current array index.
       Unlike for loops, array comprehensions are expressions, and can be returned
-      and assigned. They should be able to handle most places where you otherwise
-      would use a loop, <b>each</b>/<b>forEach</b>, <b>map</b>, or <b>select</b>/<b>filter</b>.
+      and assigned.
     </p>
     <%= code_for('array_comprehensions') %>
     <p>
+      Comprehensions should be able to handle most places where you otherwise
+      would use a loop, <b>each</b>/<b>forEach</b>, <b>map</b>, or <b>select</b>/<b>filter</b>:
+      <tt>shortNames = (name for name in list when name.length &lt; 5)</tt><br />
       If you know the start and end of your loop, or would like to step through
       in fixed-size increments, you can use a range to specify the start and
       end of your comprehension.
@@ -495,7 +504,7 @@ Expressions
       each iteration into an array. Sometimes functions end with loops that are
       intended to run only for their side-effects. Be careful that you're not
       accidentally returning the results of the comprehension in these cases,
-      by adding a meaningful return value, like <tt>true</tt>, or <tt>null</tt>,
+      by adding a meaningful return value &mdash; like <tt>true</tt> &mdash; or <tt>null</tt>,
       to the bottom of your function.
     </p>
     <p>
@@ -540,7 +549,7 @@ Expressions
       <b class="header">Array Slicing and Splicing with Ranges</b>
       Ranges can also be used to extract slices of arrays.
       With two dots (<tt>3..6</tt>), the range is inclusive (<tt>3, 4, 5, 6</tt>);
-      with three docs (<tt>3...6</tt>), the range excludes the end (<tt>3, 4, 5</tt>).
+      with three dots (<tt>3...6</tt>), the range excludes the end (<tt>3, 4, 5</tt>).
     </p>
     <%= code_for('slices', 'middle') %>
     <p>
@@ -558,7 +567,7 @@ Expressions
       to CoffeeScript functions, they nonetheless return their final value.
       The CoffeeScript compiler tries to make sure that all statements in the
       language can be used as expressions. Watch how the <tt>return</tt> gets
-      pushed down into each possible branch of execution, in the function
+      pushed down into each possible branch of execution in the function
       below.
     </p>
     <%= code_for('expressions', 'eldest') %>
@@ -699,20 +708,20 @@ Expressions
       in a single assignable expression.
     </p>
     <p>
-      Constructor functions are named, to better support reflection. In the
-      example below for the first class, <tt>this.constructor.name is "Animal"</tt>.
+      Constructor functions are named, to better support helpful stack traces.
     </p>
     <%= code_for('classes', true) %>
     <p>
       If structuring your prototypes classically isn't your cup of tea, CoffeeScript
       provides a couple of lower-level conveniences. The <tt>extends</tt> operator
-      helps with proper prototype setup, <tt>::</tt> gives you
-      quick access to an object's prototype, and <tt>super()</tt>
+      helps with proper prototype setup, and can be used to create an inheritance
+      chain between any pair of constructor functions; <tt>::</tt> gives you
+      quick access to an object's prototype; and <tt>super()</tt>
       is converted into a call against the immediate ancestor's method of the same name.
     </p>
     <%= code_for('prototypes', '"one_two".dasherize()') %>
     <p>
-      Finally class definitions are blocks of executable code, which make for interesting
+      Finally, class definitions are blocks of executable code, which make for interesting
       metaprogramming possibilities. Because in the context of a class definition,
       <tt>this</tt> is the class object itself (the constructor function), you
       can assign static properties by using <br /><tt>@property: value</tt>, and call
@@ -751,7 +760,7 @@ Expressions
       <b class="header">Function binding</b>
       In JavaScript, the <tt>this</tt> keyword is dynamically scoped to mean the
       object that the current function is attached to. If you pass a function as
-      as callback, or attach it to a different object, the original value of <tt>this</tt>
+      a callback or attach it to a different object, the original value of <tt>this</tt>
       will be lost. If you're not familiar with this behavior,
       <a href="http://www.digital-web.com/articles/scope_in_javascript/">this Digital Web article</a>
       gives a good overview of the quirks.
@@ -840,7 +849,7 @@ Expressions
     <p>
       Sometimes you'd like to pass a block comment through to the generated
       JavaScript. For example, when you need to embed a licensing header at
-      the top of a file. Block comments, which mirror the synax for heredocs,
+      the top of a file. Block comments, which mirror the syntax for heredocs,
       are preserved in the generated code.
     </p>
     <%= code_for('block_comment') %>
@@ -903,7 +912,7 @@ Expressions
 
     <p>
       In fact, the little bit of glue script that runs "Try CoffeeScript" above,
-      as well as jQuery for the menu, is implemented in just this way.
+      as well as the jQuery for the menu, is implemented in just this way.
       View source and look at the bottom of the page to see the example.
       Including the script also gives you access to <tt>CoffeeScript.compile()</tt>
       so you can pop open Firebug and try compiling some strings.
@@ -921,6 +930,10 @@ Expressions
     </h2>
 
     <ul>
+      <li>
+        <b>sstephenson</b>'s <a href="http://pow.cx/">Pow</a>,
+        a zero-configuration Rack server, with comprehensive annotated source.
+      </li>
       <li>
         <b>frank06</b>'s <a href="http://riakjs.org/">riak-js</a>, a Node.js client for
         <a href="http://www.basho.com/Riak.html">Riak</a>, with support for HTTP
@@ -930,6 +943,10 @@ Expressions
         <b>technoweenie</b>'s <a href="https://github.com/technoweenie/coffee-resque">Coffee-Resque</a>,
         a port of <a href="https://github.com/defunkt/resque">Resque</a> for Node.js.
       </li>
+      <li>
+        <b>assaf</b>'s <a href="http://zombie.labnotes.org/">Zombie.js</a>,
+        A headless, full-stack, faux-browser testing library for Node.js.
+      </li>
       <li>
         <b>jashkenas</b>' <a href="documentation/docs/underscore.html">Underscore.coffee</a>, a port
         of the <a href="http://documentcloud.github.com/underscore/">Underscore.js</a>
@@ -943,10 +960,6 @@ Expressions
         <b>josh</b>'s <a href="http://josh.github.com/nack/">nack</a>, a Node.js-powered
         <a href="http://rack.rubyforge.org/">Rack</a> server.
       </li>
-      <li>
-        <b>sstephenson</b>'s <a href="http://sstephenson.github.com/strscan-js/">StringScanner</a>,
-        a simple tokenizer and lexical scanner for JavaScript strings.
-      </li>
     </ul>
 
     <h2>
@@ -969,103 +982,23 @@ Expressions
       </li>
       <li>
         <a href="http://github.com/jashkenas/coffee-script/issues">CoffeeScript Issues</a><br />
-        Bugs reports, feature requests, and general discussion all belong here.
+        Bug reports, feature proposals, and ideas for changes to the language belong here.
       </li>
       <li>
-        If you'd like to chat, stop by <tt>#coffeescript</tt> on Freenode in the
-        IRC client of your choice, or on
-        <a href="http://webchat.freenode.net/">webchat.freenode.net</a>.
+        <a href="https://groups.google.com/forum/#!forum/coffeescript">CoffeeScript Google Group</a><br />
+        If you'd like to ask a question, the mailing list is a good place to get help.
       </li>
       <li>
-        <b>satyr</b>'s <a href="http://github.com/satyr/coco">Coco</a>
-        &mdash; An avant-garde dialect of CoffeeScript that frequently pioneers
-        features and optimizations, some of which CoffeeScript later adopts.
-        Check out the <a href="https://github.com/satyr/coco/wiki/additions">list of additions</a>
-        to the language.
+        <a href="http://github.com/jashkenas/coffee-script/wiki">The CoffeeScript Wiki</a><br />
+        If you've ever learned a neat CoffeeScript tip or trick, or ran into a gotcha &mdash; share it on the wiki.
+        The wiki also serves as a directory of handy 
+        <a href="http://github.com/jashkenas/coffee-script/wiki/Text-editor-plugins">text editor extensions</a>,
+        <a href="http://github.com/jashkenas/coffee-script/wiki/Web-framework-plugins">web framework plugins</a>,
+        and general <a href="http://github.com/jashkenas/coffee-script/wiki/Build-tools">CoffeeScript build tools</a>.
       </li>
       <li>
-        <b>yeungda</b>'s <a href="http://github.com/yeungda/jcoffeescript">JCoffeeScript</a>
-        &mdash; A Java Library that uses Rhino to compile CoffeeScript, allowing
-        compilation within Java projects or on systems that Node.js doesn't support.
-      </li>
-      <li>
-        <b>defunkt</b>'s <a href="http://github.com/defunkt/coffee-mode">CoffeeScript Major Mode</a>
-        &mdash; a Emacs major mode that provides syntax highlighting, indentation
-        support, and some bonus commands.
-      </li>
-      <li>
-        <b>jashkenas</b>' <a href="http://github.com/jashkenas/coffee-script-tmbundle">CoffeeScript TextMate Bundle</a>
-        &mdash; which provides syntax highlighting, snippet expansion, and the
-        ability to run bits of CoffeeScript from within TextMate itself.
-      </li>
-      <li>
-        <b>kchmck</b>'s <a href="http://github.com/kchmck/vim-coffee-script">Vim CoffeeScript</a>
-        &mdash; which adds Vim syntax highlighting and indentation support.
-      </li>
-      <li>
-        <b>wavded</b>'s <a href="http://github.com/wavded/gedit-coffeescript">gedit-coffeescript</a>
-        &mdash; a CoffeeScript syntax highlighter for the gedit text editor.
-      </li>
-      <li>
-        <b>yeungda</b>'s <a href="http://yeungda.github.com/coffeescript-idea/">coffeescript-idea</a>
-        &mdash; a plugin for IntelliJ IDEA and RubyMine providing syntax highlighting.
-      </li>
-      <li>
-        <b>mattly</b>'s <a href="http://github.com/mattly/rack-coffee">rack-coffee</a>
-        &mdash; a small Rack middleware for serving CoffeeScript files as
-        compiled JavaScript on the fly.
-      </li>
-      <li>
-        <b>jnicklas</b>'s <a href="http://github.com/jnicklas/bistro_car">BistroCar</a>
-        &mdash; a plugin that serves and bundles CoffeeScript from within your
-        Rails application.
-      </li>
-      <li>
-        <b>dsc</b>'s <a href="http://github.com/dsc/coffeecup">CoffeeCup</a>
-        &mdash; a Python WSGI middleware that compiles CoffeeScript to JavaScript
-        on-demand during development.
-      </li>
-      <li>
-        <b>sutto</b>'s <a href="http://github.com/Sutto/barista">Barista</a>
-        &mdash; a BistroCar alternative that integrates well with
-        <a href="http://documentcloud.github.com/jammit">Jammit</a> and Rails 3.
-      </li>
-      <li>
-        <b>inem</b> and <b>gerad</b>'s <a href="http://github.com/gerad/coffee-haml-filter">coffee-haml-filter</a>
-        &mdash; a custom filter for rendering CoffeeScript inline within
-        <a href="http://haml-lang.com/">HAML</a> templates.
-      </li>
-      <li>
-        <b>chrislloyd</b>'s <a href="http://github.com/chrislloyd/roast">Roast</a>
-        &mdash; a CoffeeScript compiler plug-in that allows you to include external
-        source files.
-      </li>
-      <li>
-        <b>andrzejsliwa</b>'s <a href="http://github.com/andrzejsliwa/coffeeapp">CoffeeApp</a>
-        &mdash; a CoffeeScript wrapper for CouchApps, web applications served
-        directly from CouchDB.
-      </li>
-      <li>
-        <b>sstephenson</b>'s <a href="http://github.com/sstephenson/eco">Eco</a>
-        &mdash; high-performance embedded CoffeeScript templates, after EJS and ERB.
-      </li>
-      <li>
-        <b>mauricemach</b>'s <a href="http://github.com/mauricemach/coffeekup">CoffeeKup</a>
-        &mdash; Markup as CoffeeScript. After _why's
-        <a href="http://markaby.github.com/">Markaby</a>.
-      </li>
-      <li>
-        <b>jashkenas</b>' <a href="http://jashkenas.github.com/docco/">Docco</a>
-        &mdash; a quick-and-dirty literate-programming-style documentation generator
-        for CoffeeScript. Used to produce the annotated source.
-      </li>
-      <li>
-        <b>naturalethic</b>'s <a href="http://github.com/naturalethic/coffee-mongo">coffee-mongo</a>
-        &mdash; an asynchronous MongoDB ORM, for use with Node.js and CoffeeScript.
-      </li>
-      <li>
-        <b>mauricemach</b>'s <a href="https://github.com/mauricemach/zappa">Zappa</a>
-        &mdash; a DSL for building web apps, built on top of Express and Socket.IO.
+        <a href="http://github.com/jashkenas/coffee-script/wiki/FAQ">The FAQ</a><br />
+        Perhaps your CoffeeScript-related question has been asked before. Check the FAQ first.
       </li>
     </ul>
 
@@ -1088,6 +1021,61 @@ Expressions
       <span id="change_log" class="bookmark"></span>
       Change Log
     </h2>
+    
+    <p>
+      <b class="header" style="margin-top: 20px;">
+        <a href="https://github.com/jashkenas/coffee-script/compare/1.1.1...1.1.2">1.1.2</a>
+        <span class="timestamp"> &ndash; <small>August 4, 2011</small></span>
+      </b>
+      We now use the native <tt>Function.prototype.bind</tt> for bound function
+      literals where available.
+      Fixes for: block comment formatting, <tt>?=</tt> compilation, implicit calls
+      against control structures, implicit invocation of a try/catch block,
+      variadic arguments leaking from local scope, line numbers in syntax errors
+      following heregexes, property access on parenthesized number literals,
+      bound class methods and super with reserved names, a REPL overhaul, 
+      consecutive compiled semicolons, block comments in implicitly called objects,
+      and a Chrome bug.
+    </p>
+    
+    <p>
+      <b class="header" style="margin-top: 20px;">1.1.1
+        <span class="timestamp"> &ndash; <small>May 10, 2011</small></span>
+      </b>
+      Bugfix release for classes with external constructor functions, see 
+      issue #1182.
+    </p>
+    
+    <p>
+      <b class="header" style="margin-top: 20px;">1.1.0
+        <span class="timestamp"> &ndash; <small>May 1, 2011</small></span>
+      </b>
+      When running via the <tt>coffee</tt> executable, <tt>process.argv</tt> and 
+      friends now report <tt>coffee</tt> instead of <tt>node</tt>.
+      Better compatibility with <b>Node.js 0.4.x</b> module lookup changes.
+      The output in the REPL is now colorized, like Node's is.
+      Giving your concatenated CoffeeScripts a name when using <tt>--join</tt> is now mandatory.
+      Fix for lexing compound division <tt>/=</tt> as a regex accidentally.
+      All <tt>text/coffeescript</tt> tags should now execute in the order they're included.
+      Fixed an issue with extended subclasses using external constructor functions.
+      Fixed an edge-case infinite loop in <tt>addImplicitParentheses</tt>.
+      Fixed exponential slowdown with long chains of function calls.
+      Globals no longer leak into the CoffeeScript REPL.
+      Splatted parameters are declared local to the function.
+    </p>
+
+    <p>
+      <b class="header" style="margin-top: 20px;">1.0.1
+        <span class="timestamp"> &ndash; <small>Jan 31, 2011</small></span>
+      </b>
+      Fixed a lexer bug with Unicode identifiers. Updated REPL for compatibility
+      with Node.js 0.3.7. Fixed requiring relative paths in the REPL. Trailing
+      <tt>return</tt> and <tt>return undefined</tt> are now optimized away.
+      Stopped requiring the core Node.js <tt>"util"</tt> module for
+      back-compatibility with Node.js 0.2.5. Fixed a case where a
+      conditional <tt>return</tt> would cause fallthrough in a <tt>switch</tt>
+      statement. Optimized empty objects in destructuring assignment.
+    </p>
 
     <p>
       <b class="header" style="margin-top: 20px;">1.0.0
@@ -1562,7 +1550,7 @@ Expressions
     $('#repl_source').keyup -> compileSource()
 
     # Eval the compiled js.
-    $('.minibutton.run').click ->
+    evalJS = ->
       try
         eval window.compiledJS
       catch error then alert error
@@ -1578,6 +1566,8 @@ Expressions
     closeMenus = ->
       $('.navigation.active').removeClass 'active'
 
+    $('.minibutton.run').click evalJS
+
     # Bind navigation buttons to open the menus.
     $('.navigation').click (e) ->
       return if e.target.tagName.toLowerCase() is 'a'
@@ -1589,9 +1579,15 @@ Expressions
         $(this).addClass 'active'
       false
 
-    $(document.body).click (e) ->
-      return false if $(e.target).hasClass('minibutton')
-      closeMenus()
+    # Dismiss console if Escape pressed or click falls outside console
+    # Trigger Run button on Ctrl-Enter
+    $(document.body)
+      .keydown (e) ->
+        closeMenus() if e.which == 27
+        evalJS() if e.which == 13 and (e.metaKey or e.ctrlKey) and $('.minibutton.run:visible').length
+      .click (e) ->
+        return false if $(e.target).hasClass('minibutton')
+        closeMenus()
 
     $('#open_webchat').click ->
       $(this).replaceWith $('<iframe src="http://webchat.freenode.net/?channels=coffeescript" width="625" height="400"></iframe>')

documentation/js/block_comment.js

@@ -1,4 +1,4 @@
 /*
-CoffeeScript Compiler v1.0.0
+CoffeeScript Compiler v1.1.2
 Released under the MIT License
 */

documentation/js/classes.js

@@ -12,15 +12,15 @@ Animal = (function() {
     this.name = name;
   }
   Animal.prototype.move = function(meters) {
-    return alert(this.name + " moved " + meters + "m.");
+    return alert(this.name + (" moved " + meters + "m."));
   };
   return Animal;
 })();
 Snake = (function() {
+  __extends(Snake, Animal);
   function Snake() {
     Snake.__super__.constructor.apply(this, arguments);
   }
-  __extends(Snake, Animal);
   Snake.prototype.move = function() {
     alert("Slithering...");
     return Snake.__super__.move.call(this, 5);
@@ -28,10 +28,10 @@ Snake = (function() {
   return Snake;
 })();
 Horse = (function() {
+  __extends(Horse, Animal);
   function Horse() {
     Horse.__super__.constructor.apply(this, arguments);
   }
-  __extends(Horse, Animal);
   Horse.prototype.move = function() {
     alert("Galloping...");
     return Horse.__super__.move.call(this, 45);

documentation/js/do.js

@@ -1,10 +1,10 @@
-var fileName, _fn, _i, _len;
-_fn = function(fileName) {
-  return fs.readFile(fileName, function(err, contents) {
-    return compile(fileName, contents.toString());
+var filename, _fn, _i, _len;
+_fn = function(filename) {
+  return fs.readFile(filename, function(err, contents) {
+    return compile(filename, contents.toString());
   });
 };
 for (_i = 0, _len = list.length; _i < _len; _i++) {
-  fileName = list[_i];
-  _fn(fileName);
+  filename = list[_i];
+  _fn(filename);
 }

documentation/js/existence.js

@@ -1,6 +1,8 @@
 var footprints, solipsism;
-if ((typeof mind != "undefined" && mind !== null) && !(typeof world != "undefined" && world !== null)) {
+if ((typeof mind !== "undefined" && mind !== null) && !(typeof world !== "undefined" && world !== null)) {
   solipsism = true;
 }
-typeof speed != "undefined" && speed !== null ? speed : speed = 75;
-footprints = typeof yeti != "undefined" && yeti !== null ? yeti : "bear";
+if (typeof speed === "undefined" || speed === null) {
+  speed = 75;
+}
+footprints = typeof yeti !== "undefined" && yeti !== null ? yeti : "bear";

documentation/js/object_comprehensions.js

@@ -9,7 +9,7 @@ ages = (function() {
   _results = [];
   for (child in yearsOld) {
     age = yearsOld[child];
-    _results.push(child + " is " + age);
+    _results.push("" + child + " is " + age);
   }
   return _results;
 })();

documentation/js/overview.js

@@ -21,7 +21,7 @@ race = function() {
   winner = arguments[0], runners = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
   return print(winner, runners);
 };
-if (typeof elvis != "undefined" && elvis !== null) {
+if (typeof elvis !== "undefined" && elvis !== null) {
   alert("I knew it!");
 }
 cubes = (function() {

documentation/js/while.js

@@ -12,7 +12,7 @@ lyrics = (function() {
   var _results;
   _results = [];
   while (num -= 1) {
-    _results.push(num + " little monkeys, jumping on the bed.    One fell out and bumped his head.");
+    _results.push("" + num + " little monkeys, jumping on the bed.    One fell out and bumped his head.");
   }
   return _results;
 })();

examples/underscore.coffee

@@ -1,5 +1,5 @@
 # **Underscore.coffee
-# (c) 2010 Jeremy Ashkenas, DocumentCloud Inc.**
+# (c) 2011 Jeremy Ashkenas, DocumentCloud Inc.**
 # Underscore is freely distributable under the terms of the
 # [MIT license](http://en.wikipedia.org/wiki/MIT_License).
 # Portions of Underscore are inspired by or borrowed from

extras/EXTRAS

@@ -1,7 +0,0 @@
-EXTRAS:
-
-"extras/coffee-script.js" is a concatenated and compressed version of the 
-CoffeeScript compiler. To use it in the browser, include the script after any 
-inline script tags of type "text/coffeescript" on the page. It will compile
-and evaluate all of the scripts in order.
-

index.html

@@ -58,10 +58,10 @@
           <div class="screenshadow bl"></div>
           <div class="screenshadow br"></div>
           <div id="repl_source_wrap">
-            <textarea id="repl_source" rows="100">alert "Hello CoffeeScript!"</textarea>
+            <textarea id="repl_source" rows="100" spellcheck="false">alert "Hello CoffeeScript!"</textarea>
           </div>
           <div id="repl_results_wrap"><pre id="repl_results"></pre></div>
-          <div class="minibutton dark run">Run</div>
+          <div class="minibutton dark run" title="Ctrl-Enter">Run</div>
           <br class="clear" />
         </div>
       </div>
@@ -109,7 +109,7 @@
 
     <p>
       <b>Latest Version:</b>
-      <a href="http://github.com/jashkenas/coffee-script/tarball/1.0.0">1.0.0</a>
+      <a href="http://github.com/jashkenas/coffee-script/tarball/1.1.2">1.1.2</a>
     </p>
 
     <h2>
@@ -170,7 +170,7 @@ math <span class="Keyword">=</span> {
   winner <span class="Keyword">=</span> arguments[<span class="Number">0</span>], runners <span class="Keyword">=</span> <span class="Number">2</span> <span class="Keyword">&lt;=</span> arguments.<span class="LibraryConstant">length</span> ? __slice.<span class="LibraryFunction">call</span>(arguments, <span class="Number">1</span>) : [];
   <span class="Keyword">return</span> <span class="LibraryFunction">print</span>(winner, runners);
 };
-<span class="Keyword">if</span> (<span class="Keyword">typeof</span> elvis <span class="Keyword">!</span><span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> elvis <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span>) {
+<span class="Keyword">if</span> (<span class="Keyword">typeof</span> elvis <span class="Keyword">!</span><span class="Keyword">==</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> elvis <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span>) {
   <span class="LibraryFunction">alert</span>(<span class="String"><span class="String">&quot;</span>I knew it!<span class="String">&quot;</span></span>);
 }
 cubes <span class="Keyword">=</span> (<span class="Storage">function</span>() {
@@ -205,7 +205,7 @@ race = function() {
   winner = arguments[0], runners = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
   return print(winner, runners);
 };
-if (typeof elvis != "undefined" && elvis !== null) {
+if (typeof elvis !== "undefined" && elvis !== null) {
   alert("I knew it!");
 }
 cubes = (function() {
@@ -241,17 +241,21 @@ cubes = (function() {
     </p>
 
     <pre>
-npm install coffee-script</pre>
+npm install -g coffee-script</pre>
 
-  <p>
-    If you'd prefer to install the latest master version of CoffeeScript, you
-    can clone the CoffeeScript
-    <a href="http://github.com/jashkenas/coffee-script">source repository</a>
-    from GitHub, or download
-    <a href="http://github.com/jashkenas/coffee-script/tarball/master">the source</a> directly.
-    To install the CoffeeScript compiler system-wide
-    under <tt>/usr/local</tt>, open the directory and run:
-  </p>
+    <p>
+      (Leave off the <tt>-g</tt> if you don't wish to install globally.)
+    </p>
+    
+    <p>
+      If you'd prefer to install the latest master version of CoffeeScript, you
+      can clone the CoffeeScript
+      <a href="http://github.com/jashkenas/coffee-script">source repository</a>
+      from GitHub, or download
+      <a href="http://github.com/jashkenas/coffee-script/tarball/master">the source</a> directly.
+      To install the CoffeeScript compiler system-wide
+      under <tt>/usr/local</tt>, open the directory and run:
+    </p>
 
   <pre>
 sudo bin/cake install</pre>
@@ -260,7 +264,9 @@ sudo bin/cake install</pre>
       If installing on Ubuntu or Debian,
       <a href="http://opinionated-programmer.com/2010/12/installing-coffeescript-on-debian-or-ubuntu/">be
       careful not to use the existing out-of-date package</a>. If installing on
-      Windows, your best bet is probably to run Node.js under Cygwin.
+      Windows, your best bet is probably to run Node.js under Cygwin. If you'd
+      just like to experiment, you can try the 
+      <a href="https://github.com/alisey/CoffeeScript-Compiler-for-Windows">CoffeeScript Compiler For Windows</a>.
     </p>
 
     <p>
@@ -294,10 +300,11 @@ sudo bin/cake install</pre>
         </td>
       </tr>
       <tr>
-        <td><code>-j, --join</code></td>
+        <td><code>-j, --join [FILE]</code></td>
         <td>
           Before compiling, concatenate all scripts together in the order they
-          were passed. Useful for building large projects.
+          were passed, and write them into the specified file. 
+          Useful for building large projects.
         </td>
       </tr>
       <tr>
@@ -336,7 +343,7 @@ sudo bin/cake install</pre>
         <td><code>-e, --eval</code></td>
         <td>
           Compile and print a little snippet of CoffeeScript directly from the
-          command line. For example:<br /><tt>coffee -e "puts num for num in [10..1]"</tt>
+          command line. For example:<br /><tt>coffee -e "console.log num for num in [10..1]"</tt>
         </td>
       </tr>
       <tr>
@@ -379,7 +386,7 @@ Expressions
         <td><code>--nodejs</code></td>
         <td>
           The <tt>node</tt> executable has some useful options you can set,
-          such as<br /> <tt>--debug</tt> and <tt>--max-stack-size</tt>. Use this
+          such as<br /> <tt>--debug</tt>, <tt>--debug-brk</tt> and <tt>--max-stack-size</tt>. Use this
           flag to forward options directly to Node.js.
         </td>
       </tr>
@@ -401,7 +408,7 @@ Expressions
       </li>
       <li>
         Concatenate a list of files into a single script:<br />
-        <tt>coffee -o lib/ --join --compile src/*.coffee</tt>
+        <tt>coffee --join project.js --compile src/*.coffee</tt>
       </li>
       <li>
         Print out the compiled JS from a one-liner:<br />
@@ -437,8 +444,8 @@ Expressions
     <p>
       First, the basics: CoffeeScript uses significant whitespace to delimit blocks of code.
       You don't need to use semicolons <tt>;</tt> to terminate expressions,
-      ending the line will do just as well, (although semicolons can still
-      be used to fit multiple expressions onto a single line.)
+      ending the line will do just as well (although semicolons can still
+      be used to fit multiple expressions onto a single line).
       Instead of using curly braces
       <tt>{ }</tt> to surround blocks of code in <a href="#functions">functions</a>,
       <a href="#conditionals">if-statements</a>,
@@ -634,7 +641,7 @@ inner = changeNumbers();;alert(inner);'>run: inner</div><br class='clear' /></di
       If you'd like to create top-level variables for other scripts to use,
       attach them as properties on <b>window</b>, or on the <b>exports</b>
       object in CommonJS. The <b>existential operator</b> (covered below), gives you a
-      reliable way to figure out where to add them, if you're targeting both
+      reliable way to figure out where to add them; if you're targeting both
       CommonJS and the browser: <tt>exports ? this</tt>
     </p>
 
@@ -752,8 +759,7 @@ alert("The Field: " + rest);;'>run</div><br class='clear' /></div>
       over arrays, objects, and ranges. Comprehensions replace (and compile into)
       <b>for</b> loops, with optional guard clauses and the value of the current array index.
       Unlike for loops, array comprehensions are expressions, and can be returned
-      and assigned. They should be able to handle most places where you otherwise
-      would use a loop, <b>each</b>/<b>forEach</b>, <b>map</b>, or <b>select</b>/<b>filter</b>.
+      and assigned.
     </p>
     <div class='code'><pre class="idle"><span class="Comment"><span class="Comment">#</span> Eat lunch.</span>
 eat food <span class="Keyword">for</span> food <span class="Keyword">in</span> [<span class="String"><span class="String">'</span>toast<span class="String">'</span></span>, <span class="String"><span class="String">'</span>cheese<span class="String">'</span></span>, <span class="String"><span class="String">'</span>wine<span class="String">'</span></span>]
@@ -765,6 +771,9 @@ _ref <span class="Keyword">=</span> [<span class="String"><span class="String">'
 }
 </pre><script>window.example9 = "# Eat lunch.\neat food for food in ['toast', 'cheese', 'wine']\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example9);'>load</div><br class='clear' /></div>
     <p>
+      Comprehensions should be able to handle most places where you otherwise
+      would use a loop, <b>each</b>/<b>forEach</b>, <b>map</b>, or <b>select</b>/<b>filter</b>:
+      <tt>shortNames = (name for name in list when name.length &lt; 5)</tt><br />
       If you know the start and end of your loop, or would like to step through
       in fixed-size increments, you can use a range to specify the start and
       end of your comprehension.
@@ -795,7 +804,7 @@ countdown = (function() {
       each iteration into an array. Sometimes functions end with loops that are
       intended to run only for their side-effects. Be careful that you're not
       accidentally returning the results of the comprehension in these cases,
-      by adding a meaningful return value, like <tt>true</tt>, or <tt>null</tt>,
+      by adding a meaningful return value &mdash; like <tt>true</tt> &mdash; or <tt>null</tt>,
       to the bottom of your function.
     </p>
     <p>
@@ -811,7 +820,7 @@ countdown = (function() {
     <div class='code'><pre class="idle">yearsOld <span class="Keyword">=</span> max: <span class="Number">10</span>, ida: <span class="Number">9</span>, tim: <span class="Number">11</span>
 
 ages <span class="Keyword">=</span> <span class="Keyword">for</span> child, age <span class="Keyword">of</span> yearsOld
-  child <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> is <span class="String">&quot;</span></span> <span class="Keyword">+</span> age
+  <span class="String"><span class="String">&quot;</span><span class="String"><span class="String">#{</span>child<span class="String">}</span></span> is <span class="String"><span class="String">#{</span>age<span class="String">}</span></span><span class="String">&quot;</span></span>
 </pre><pre class="idle"><span class="Storage">var</span> age, ages, child, yearsOld;
 yearsOld <span class="Keyword">=</span> {
   max: <span class="Number">10</span>,
@@ -823,11 +832,11 @@ ages <span class="Keyword">=</span> (<span class="Storage">function</span>() {
   _results <span class="Keyword">=</span> [];
   <span class="Keyword">for</span> (child <span class="Keyword">in</span> yearsOld) {
     age <span class="Keyword">=</span> yearsOld[child];
-    _results.<span class="LibraryFunction">push</span>(child <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> is <span class="String">&quot;</span></span> <span class="Keyword">+</span> age);
+    _results.<span class="LibraryFunction">push</span>(<span class="String"><span class="String">&quot;</span><span class="String">&quot;</span></span> <span class="Keyword">+</span> child <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> is <span class="String">&quot;</span></span> <span class="Keyword">+</span> age);
   }
   <span class="Keyword">return</span> _results;
 })();
-</pre><script>window.example11 = "yearsOld = max: 10, ida: 9, tim: 11\n\nages = for child, age of yearsOld\n  child + \" is \" + age\n\nalert ages.join(\", \")"</script><div class='minibutton load' onclick='javascript: loadConsole(example11);'>load</div><div class='minibutton ok' onclick='javascript: var age, ages, child, yearsOld;
+</pre><script>window.example11 = "yearsOld = max: 10, ida: 9, tim: 11\n\nages = for child, age of yearsOld\n  \"#{child} is #{age}\"\n\nalert ages.join(\", \")"</script><div class='minibutton load' onclick='javascript: loadConsole(example11);'>load</div><div class='minibutton ok' onclick='javascript: var age, ages, child, yearsOld;
 yearsOld = {
   max: 10,
   ida: 9,
@@ -838,7 +847,7 @@ ages = (function() {
   _results = [];
   for (child in yearsOld) {
     age = yearsOld[child];
-    _results.push(child + " is " + age);
+    _results.push("" + child + " is " + age);
   }
   return _results;
 })();;alert(ages.join(", "));'>run: ages.join(", ")</div><br class='clear' /></div>
@@ -862,7 +871,7 @@ ages = (function() {
 <span class="Comment"><span class="Comment">#</span> Nursery Rhyme</span>
 num <span class="Keyword">=</span> <span class="Number">6</span>
 lyrics <span class="Keyword">=</span> <span class="Keyword">while</span> num <span class="Keyword">-</span><span class="Keyword">=</span> <span class="Number">1</span>
-  num <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> little monkeys, jumping on the bed.</span>
+  <span class="String"><span class="String">&quot;</span><span class="String"><span class="String">#{</span>num<span class="String">}</span></span> little monkeys, jumping on the bed.</span>
 <span class="String">    One fell out and bumped his head.<span class="String">&quot;</span></span>
 </pre><pre class="idle"><span class="Storage">var</span> lyrics, num;
 <span class="Keyword">if</span> (<span class="Variable">this</span>.studyingEconomics) {
@@ -878,11 +887,11 @@ lyrics <span class="Keyword">=</span> (<span class="Storage">function</span>() {
   <span class="Storage">var</span> _results;
   _results <span class="Keyword">=</span> [];
   <span class="Keyword">while</span> (num <span class="Keyword">-</span><span class="Keyword">=</span> <span class="Number">1</span>) {
-    _results.<span class="LibraryFunction">push</span>(num <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> little monkeys, jumping on the bed.    One fell out and bumped his head.<span class="String">&quot;</span></span>);
+    _results.<span class="LibraryFunction">push</span>(<span class="String"><span class="String">&quot;</span><span class="String">&quot;</span></span> <span class="Keyword">+</span> num <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> little monkeys, jumping on the bed.    One fell out and bumped his head.<span class="String">&quot;</span></span>);
   }
   <span class="Keyword">return</span> _results;
 })();
-</pre><script>window.example12 = "# Econ 101\nif this.studyingEconomics\n  buy()  while supply > demand\n  sell() until supply > demand\n\n# Nursery Rhyme\nnum = 6\nlyrics = while num -= 1\n  num + \" little monkeys, jumping on the bed.\n    One fell out and bumped his head.\"\n\nalert lyrics.join(\"\\n\")"</script><div class='minibutton load' onclick='javascript: loadConsole(example12);'>load</div><div class='minibutton ok' onclick='javascript: var lyrics, num;
+</pre><script>window.example12 = "# Econ 101\nif this.studyingEconomics\n  buy()  while supply > demand\n  sell() until supply > demand\n\n# Nursery Rhyme\nnum = 6\nlyrics = while num -= 1\n  \"#{num} little monkeys, jumping on the bed.\n    One fell out and bumped his head.\"\n\nalert lyrics.join(\"\\n\")"</script><div class='minibutton load' onclick='javascript: loadConsole(example12);'>load</div><div class='minibutton ok' onclick='javascript: var lyrics, num;
 if (this.studyingEconomics) {
   while (supply > demand) {
     buy();
@@ -896,7 +905,7 @@ lyrics = (function() {
   var _results;
   _results = [];
   while (num -= 1) {
-    _results.push(num + " little monkeys, jumping on the bed.    One fell out and bumped his head.");
+    _results.push("" + num + " little monkeys, jumping on the bed.    One fell out and bumped his head.");
   }
   return _results;
 })();;alert(lyrics.join("\n"));'>run: lyrics.join("\n")</div><br class='clear' /></div>
@@ -911,28 +920,28 @@ lyrics = (function() {
       provides the <tt>do</tt> keyword, which immediately invokes a passed function,
       forwarding any arguments.
     </p>
-    <div class='code'><pre class="idle"><span class="Keyword">for</span> fileName <span class="Keyword">in</span> list
-  <span class="Keyword">do</span> <span class="FunctionArgument">(fileName)</span> <span class="Storage">-&gt;</span>
-    fs.readFile fileName, <span class="FunctionArgument">(err, contents)</span> <span class="Storage">-&gt;</span>
-      compile fileName, contents.toString()
-</pre><pre class="idle"><span class="Storage">var</span> fileName, _fn, _i, _len;
-<span class="FunctionName">_fn</span> = <span class="Storage">function</span>(<span class="FunctionArgument">fileName</span>) {
-  <span class="Keyword">return</span> fs.readFile(fileName, <span class="Storage">function</span>(err, contents) {
-    <span class="Keyword">return</span> <span class="LibraryFunction">compile</span>(fileName, contents.<span class="LibraryFunction">toString</span>());
+    <div class='code'><pre class="idle"><span class="Keyword">for</span> filename <span class="Keyword">in</span> list
+  <span class="Keyword">do</span> <span class="FunctionArgument">(filename)</span> <span class="Storage">-&gt;</span>
+    fs.readFile filename, <span class="FunctionArgument">(err, contents)</span> <span class="Storage">-&gt;</span>
+      compile filename, contents.toString()
+</pre><pre class="idle"><span class="Storage">var</span> filename, _fn, _i, _len;
+<span class="FunctionName">_fn</span> = <span class="Storage">function</span>(<span class="FunctionArgument">filename</span>) {
+  <span class="Keyword">return</span> fs.readFile(filename, <span class="Storage">function</span>(err, contents) {
+    <span class="Keyword">return</span> <span class="LibraryFunction">compile</span>(filename, contents.<span class="LibraryFunction">toString</span>());
   });
 };
 <span class="Keyword">for</span> (_i <span class="Keyword">=</span> <span class="Number">0</span>, _len <span class="Keyword">=</span> list.<span class="LibraryConstant">length</span>; _i <span class="Keyword">&lt;</span> _len; _i<span class="Keyword">++</span>) {
-  fileName <span class="Keyword">=</span> list[_i];
-  _fn(fileName);
+  filename <span class="Keyword">=</span> list[_i];
+  _fn(filename);
 }
-</pre><script>window.example13 = "for fileName in list\n  do (fileName) ->\n    fs.readFile fileName, (err, contents) ->\n      compile fileName, contents.toString()"</script><div class='minibutton load' onclick='javascript: loadConsole(example13);'>load</div><br class='clear' /></div>
+</pre><script>window.example13 = "for filename in list\n  do (filename) ->\n    fs.readFile filename, (err, contents) ->\n      compile filename, contents.toString()"</script><div class='minibutton load' onclick='javascript: loadConsole(example13);'>load</div><br class='clear' /></div>
 
     <p>
       <span id="slices" class="bookmark"></span>
       <b class="header">Array Slicing and Splicing with Ranges</b>
       Ranges can also be used to extract slices of arrays.
       With two dots (<tt>3..6</tt>), the range is inclusive (<tt>3, 4, 5, 6</tt>);
-      with three docs (<tt>3...6</tt>), the range excludes the end (<tt>3, 4, 5</tt>).
+      with three dots (<tt>3...6</tt>), the range excludes the end (<tt>3, 4, 5</tt>).
     </p>
     <div class='code'><pre class="idle">numbers <span class="Keyword">=</span> [<span class="Number">0</span>, <span class="Number">1</span>, <span class="Number">2</span>, <span class="Number">3</span>, <span class="Number">4</span>, <span class="Number">5</span>, <span class="Number">6</span>, <span class="Number">7</span>, <span class="Number">8</span>, <span class="Number">9</span>]
 
@@ -974,7 +983,7 @@ numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
       to CoffeeScript functions, they nonetheless return their final value.
       The CoffeeScript compiler tries to make sure that all statements in the
       language can be used as expressions. Watch how the <tt>return</tt> gets
-      pushed down into each possible branch of execution, in the function
+      pushed down into each possible branch of execution in the function
       below.
     </p>
     <div class='code'><pre class="idle"><span class="FunctionName">grade </span><span class="Keyword">=</span> <span class="FunctionArgument">(student)</span> <span class="Storage">-&gt;</span>
@@ -1067,7 +1076,7 @@ globals = ((function() {
   <span class="Keyword">try</span>
     nonexistent <span class="Keyword">/</span> <span class="BuiltInConstant">undefined</span>
   <span class="Keyword">catch</span> error
-    <span class="String"><span class="String">&quot;</span>And the error is ... <span class="String">&quot;</span></span> <span class="Keyword">+</span> error
+    <span class="String"><span class="String">&quot;</span>And the error is ... <span class="String"><span class="String">#{</span>error<span class="String">}</span></span><span class="String">&quot;</span></span>
 )
 
 </pre><pre class="idle"><span class="LibraryFunction">alert</span>((<span class="Storage">function</span>() {
@@ -1077,7 +1086,7 @@ globals = ((function() {
     <span class="Keyword">return</span> <span class="String"><span class="String">&quot;</span>And the error is ... <span class="String">&quot;</span></span> <span class="Keyword">+</span> error;
   }
 })());
-</pre><script>window.example19 = "alert(\n  try\n    nonexistent / undefined\n  catch error\n    \"And the error is ... \" + error\n)\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example19);'>load</div><div class='minibutton ok' onclick='javascript: alert((function() {
+</pre><script>window.example19 = "alert(\n  try\n    nonexistent / undefined\n  catch error\n    \"And the error is ... #{error}\"\n)\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example19);'>load</div><div class='minibutton ok' onclick='javascript: alert((function() {
   try {
     return nonexistent / void 0;
   } catch (error) {
@@ -1156,7 +1165,7 @@ letTheWildRumpusBegin() <span class="Keyword">unless</span> answer <span class="
 
 winner <span class="Keyword">=</span> <span class="BuiltInConstant">yes</span> <span class="Keyword">if</span> pick <span class="Keyword">in</span> [<span class="Number">47</span>, <span class="Number">92</span>, <span class="Number">13</span>]
 
-print inspect <span class="String"><span class="String">&quot;</span>My name is <span class="String">&quot;</span></span> <span class="Keyword">+</span> <span class="Variable">@name</span>
+print inspect <span class="String"><span class="String">&quot;</span>My name is <span class="String"><span class="String">#{</span><span class="Variable">@name</span><span class="String">}</span></span><span class="String">&quot;</span></span>
 </pre><pre class="idle"><span class="Storage">var</span> volume, winner;
 <span class="Keyword">if</span> (ignition <span class="Keyword">===</span> <span class="BuiltInConstant">true</span>) {
   launch();
@@ -1174,7 +1183,7 @@ print inspect <span class="String"><span class="String">&quot;</span>My name is
   winner <span class="Keyword">=</span> <span class="BuiltInConstant">true</span>;
 }
 <span class="LibraryFunction">print</span>(inspect(<span class="String"><span class="String">&quot;</span>My name is <span class="String">&quot;</span></span> <span class="Keyword">+</span> <span class="Variable">this</span>.<span class="LibraryConstant">name</span>));
-</pre><script>window.example20 = "launch() if ignition is on\n\nvolume = 10 if band isnt SpinalTap\n\nletTheWildRumpusBegin() unless answer is no\n\nif car.speed < limit then accelerate()\n\nwinner = yes if pick in [47, 92, 13]\n\nprint inspect \"My name is \" + @name\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example20);'>load</div><br class='clear' /></div>
+</pre><script>window.example20 = "launch() if ignition is on\n\nvolume = 10 if band isnt SpinalTap\n\nletTheWildRumpusBegin() unless answer is no\n\nif car.speed < limit then accelerate()\n\nwinner = yes if pick in [47, 92, 13]\n\nprint inspect \"My name is #{@name}\"\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example20);'>load</div><br class='clear' /></div>
 
     <p>
       <b class="header">The Existential Operator</b>
@@ -1199,17 +1208,21 @@ footprints <span class="Keyword">=</span> yeti <span class="Keyword">?</span> <s
 
 
 </pre><pre class="idle"><span class="Storage">var</span> footprints, solipsism;
-<span class="Keyword">if</span> ((<span class="Keyword">typeof</span> mind <span class="Keyword">!</span><span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> mind <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span>) <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> <span class="Keyword">!</span>(<span class="Keyword">typeof</span> world <span class="Keyword">!</span><span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> world <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span>)) {
+<span class="Keyword">if</span> ((<span class="Keyword">typeof</span> mind <span class="Keyword">!</span><span class="Keyword">==</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> mind <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span>) <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> <span class="Keyword">!</span>(<span class="Keyword">typeof</span> world <span class="Keyword">!</span><span class="Keyword">==</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> world <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span>)) {
   solipsism <span class="Keyword">=</span> <span class="BuiltInConstant">true</span>;
 }
-<span class="Keyword">typeof</span> speed <span class="Keyword">!</span><span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> speed <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span> ? speed : speed <span class="Keyword">=</span> <span class="Number">75</span>;
-footprints <span class="Keyword">=</span> <span class="Keyword">typeof</span> yeti <span class="Keyword">!</span><span class="Keyword">=</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> yeti <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span> ? yeti : <span class="String"><span class="String">&quot;</span>bear<span class="String">&quot;</span></span>;
+<span class="Keyword">if</span> (<span class="Keyword">typeof</span> speed <span class="Keyword">===</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">||</span> speed <span class="Keyword">===</span> <span class="BuiltInConstant">null</span>) {
+  speed <span class="Keyword">=</span> <span class="Number">75</span>;
+}
+footprints <span class="Keyword">=</span> <span class="Keyword">typeof</span> yeti <span class="Keyword">!</span><span class="Keyword">==</span> <span class="String"><span class="String">&quot;</span>undefined<span class="String">&quot;</span></span> <span class="Keyword">&amp;</span><span class="Keyword">&amp;</span> yeti <span class="Keyword">!</span><span class="Keyword">==</span> <span class="BuiltInConstant">null</span> ? yeti : <span class="String"><span class="String">&quot;</span>bear<span class="String">&quot;</span></span>;
 </pre><script>window.example21 = "solipsism = true if mind? and not world?\n\nspeed ?= 75\n\nfootprints = yeti ? \"bear\"\n\nalert footprints"</script><div class='minibutton load' onclick='javascript: loadConsole(example21);'>load</div><div class='minibutton ok' onclick='javascript: var footprints, solipsism;
-if ((typeof mind != "undefined" && mind !== null) && !(typeof world != "undefined" && world !== null)) {
+if ((typeof mind !== "undefined" && mind !== null) && !(typeof world !== "undefined" && world !== null)) {
   solipsism = true;
 }
-typeof speed != "undefined" && speed !== null ? speed : speed = 75;
-footprints = typeof yeti != "undefined" && yeti !== null ? yeti : "bear";;alert(footprints);'>run: footprints</div><br class='clear' /></div>
+if (typeof speed === "undefined" || speed === null) {
+  speed = 75;
+}
+footprints = typeof yeti !== "undefined" && yeti !== null ? yeti : "bear";;alert(footprints);'>run: footprints</div><br class='clear' /></div>
     <p>
       The accessor variant of the existential operator <tt>?.</tt> can be used to soak
       up null references in a chain of properties. Use it instead
@@ -1251,14 +1264,13 @@ zip <span class="Keyword">=</span> <span class="Keyword">typeof</span> lottery.d
       in a single assignable expression.
     </p>
     <p>
-      Constructor functions are named, to better support reflection. In the
-      example below for the first class, <tt>this.constructor.name is "Animal"</tt>.
+      Constructor functions are named, to better support helpful stack traces.
     </p>
     <div class='code'><pre class="idle"><span class="Storage">class</span> <span class="TypeName">Animal</span>
   <span class="FunctionName">constructor</span><span class="Keyword">:</span> <span class="FunctionArgument">(@name)</span> <span class="Storage">-&gt;</span>
 
   <span class="FunctionName">move</span><span class="Keyword">:</span> <span class="FunctionArgument">(meters)</span> <span class="Storage">-&gt;</span>
-    alert <span class="Variable">@name</span> <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> moved <span class="String">&quot;</span></span> <span class="Keyword">+</span> meters <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span>m.<span class="String">&quot;</span></span>
+    alert <span class="Variable">@name</span> <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> moved <span class="String"><span class="String">#{</span>meters<span class="String">}</span></span>m.<span class="String">&quot;</span></span>
 
 <span class="Storage">class</span> <span class="TypeName">Snake</span><span class="InheritedClass"> <span class="Keyword">extends</span> Animal</span>
   <span class="FunctionName">move</span><span class="Keyword">:</span> <span class="Keyword">-</span><span class="Keyword">&gt;</span>
@@ -1293,15 +1305,15 @@ Animal <span class="Keyword">=</span> (<span class="Storage">function</span>() {
     <span class="Variable">this</span>.<span class="LibraryConstant">name</span> <span class="Keyword">=</span> name;
   }
   <span class="LibraryClassType">Animal</span>.<span class="LibraryConstant">prototype</span>.<span class="FunctionName">move</span> = <span class="Storage">function</span>(<span class="FunctionArgument">meters</span>) {
-    <span class="Keyword">return</span> <span class="LibraryFunction">alert</span>(<span class="Variable">this</span>.<span class="LibraryConstant">name</span> <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span> moved <span class="String">&quot;</span></span> <span class="Keyword">+</span> meters <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span>m.<span class="String">&quot;</span></span>);
+    <span class="Keyword">return</span> <span class="LibraryFunction">alert</span>(<span class="Variable">this</span>.<span class="LibraryConstant">name</span> <span class="Keyword">+</span> (<span class="String"><span class="String">&quot;</span> moved <span class="String">&quot;</span></span> <span class="Keyword">+</span> meters <span class="Keyword">+</span> <span class="String"><span class="String">&quot;</span>m.<span class="String">&quot;</span></span>));
   };
   <span class="Keyword">return</span> Animal;
 })();
 Snake <span class="Keyword">=</span> (<span class="Storage">function</span>() {
+  __extends(Snake, Animal);
   <span class="Storage">function</span> <span class="FunctionName">Snake</span>() {
     Snake.__super__.<span class="LibraryConstant">constructor</span>.<span class="LibraryFunction">apply</span>(<span class="Variable">this</span>, arguments);
   }
-  __extends(Snake, Animal);
   <span class="LibraryClassType">Snake</span>.<span class="LibraryConstant">prototype</span>.<span class="FunctionName">move</span> = <span class="Storage">function</span>() {
     <span class="LibraryFunction">alert</span>(<span class="String"><span class="String">&quot;</span>Slithering...<span class="String">&quot;</span></span>);
     <span class="Keyword">return</span> Snake.__super__.move.<span class="LibraryFunction">call</span>(<span class="Variable">this</span>, <span class="Number">5</span>);
@@ -1309,10 +1321,10 @@ Snake <span class="Keyword">=</span> (<span class="Storage">function</span>() {
   <span class="Keyword">return</span> Snake;
 })();
 Horse <span class="Keyword">=</span> (<span class="Storage">function</span>() {
+  __extends(Horse, Animal);
   <span class="Storage">function</span> <span class="FunctionName">Horse</span>() {
     Horse.__super__.<span class="LibraryConstant">constructor</span>.<span class="LibraryFunction">apply</span>(<span class="Variable">this</span>, arguments);
   }
-  __extends(Horse, Animal);
   <span class="LibraryClassType">Horse</span>.<span class="LibraryConstant">prototype</span>.<span class="FunctionName">move</span> = <span class="Storage">function</span>() {
     <span class="LibraryFunction">alert</span>(<span class="String"><span class="String">&quot;</span>Galloping...<span class="String">&quot;</span></span>);
     <span class="Keyword">return</span> Horse.__super__.move.<span class="LibraryFunction">call</span>(<span class="Variable">this</span>, <span class="Number">45</span>);
@@ -1323,7 +1335,7 @@ sam <span class="Keyword">=</span> <span class="Keyword">new</span> <span class=
 tom <span class="Keyword">=</span> <span class="Keyword">new</span> <span class="TypeName">Horse</span>(<span class="String"><span class="String">&quot;</span>Tommy the Palomino<span class="String">&quot;</span></span>);
 sam.move();
 tom.move();
-</pre><script>window.example23 = "class Animal\n  constructor: (@name) ->\n\n  move: (meters) ->\n    alert @name + \" moved \" + meters + \"m.\"\n\nclass Snake extends Animal\n  move: ->\n    alert \"Slithering...\"\n    super 5\n\nclass Horse extends Animal\n  move: ->\n    alert \"Galloping...\"\n    super 45\n\nsam = new Snake \"Sammy the Python\"\ntom = new Horse \"Tommy the Palomino\"\n\nsam.move()\ntom.move()\n\n\n\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example23);'>load</div><div class='minibutton ok' onclick='javascript: var Animal, Horse, Snake, sam, tom;
+</pre><script>window.example23 = "class Animal\n  constructor: (@name) ->\n\n  move: (meters) ->\n    alert @name + \" moved #{meters}m.\"\n\nclass Snake extends Animal\n  move: ->\n    alert \"Slithering...\"\n    super 5\n\nclass Horse extends Animal\n  move: ->\n    alert \"Galloping...\"\n    super 45\n\nsam = new Snake \"Sammy the Python\"\ntom = new Horse \"Tommy the Palomino\"\n\nsam.move()\ntom.move()\n\n\n\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example23);'>load</div><div class='minibutton ok' onclick='javascript: var Animal, Horse, Snake, sam, tom;
 var __hasProp = Object.prototype.hasOwnProperty, __extends = function(child, parent) {
   for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; }
   function ctor() { this.constructor = child; }
@@ -1337,15 +1349,15 @@ Animal = (function() {
     this.name = name;
   }
   Animal.prototype.move = function(meters) {
-    return alert(this.name + " moved " + meters + "m.");
+    return alert(this.name + (" moved " + meters + "m."));
   };
   return Animal;
 })();
 Snake = (function() {
+  __extends(Snake, Animal);
   function Snake() {
     Snake.__super__.constructor.apply(this, arguments);
   }
-  __extends(Snake, Animal);
   Snake.prototype.move = function() {
     alert("Slithering...");
     return Snake.__super__.move.call(this, 5);
@@ -1353,10 +1365,10 @@ Snake = (function() {
   return Snake;
 })();
 Horse = (function() {
+  __extends(Horse, Animal);
   function Horse() {
     Horse.__super__.constructor.apply(this, arguments);
   }
-  __extends(Horse, Animal);
   Horse.prototype.move = function() {
     alert("Galloping...");
     return Horse.__super__.move.call(this, 45);
@@ -1370,8 +1382,9 @@ tom.move();;'>run</div><br class='clear' /></div>
     <p>
       If structuring your prototypes classically isn't your cup of tea, CoffeeScript
       provides a couple of lower-level conveniences. The <tt>extends</tt> operator
-      helps with proper prototype setup, <tt>::</tt> gives you
-      quick access to an object's prototype, and <tt>super()</tt>
+      helps with proper prototype setup, and can be used to create an inheritance
+      chain between any pair of constructor functions; <tt>::</tt> gives you
+      quick access to an object's prototype; and <tt>super()</tt>
       is converted into a call against the immediate ancestor's method of the same name.
     </p>
     <div class='code'><pre class="idle"><span class="FunctionName">String::dasherize </span><span class="Keyword">=</span> <span class="Keyword">-</span><span class="Keyword">&gt;</span>
@@ -1384,7 +1397,7 @@ tom.move();;'>run</div><br class='clear' /></div>
   return this.replace(/_/g, "-");
 };;alert("one_two".dasherize());'>run: "one_two".dasherize()</div><br class='clear' /></div>
     <p>
-      Finally class definitions are blocks of executable code, which make for interesting
+      Finally, class definitions are blocks of executable code, which make for interesting
       metaprogramming possibilities. Because in the context of a class definition,
       <tt>this</tt> is the class object itself (the constructor function), you
       can assign static properties by using <br /><tt>@property: value</tt>, and call
@@ -1498,7 +1511,7 @@ _ref = tag.split(""), open = _ref[0], contents = 3 <= _ref.length ? __slice.call
       <b class="header">Function binding</b>
       In JavaScript, the <tt>this</tt> keyword is dynamically scoped to mean the
       object that the current function is attached to. If you pass a function as
-      as callback, or attach it to a different object, the original value of <tt>this</tt>
+      a callback or attach it to a different object, the original value of <tt>this</tt>
       will be lost. If you're not familiar with this behavior,
       <a href="http://www.digital-web.com/articles/scope_in_javascript/">this Digital Web article</a>
       gives a good overview of the quirks.
@@ -1706,20 +1719,20 @@ html <span class="Keyword">=</span> <span class="String"><span class="String">'<
     <p>
       Sometimes you'd like to pass a block comment through to the generated
       JavaScript. For example, when you need to embed a licensing header at
-      the top of a file. Block comments, which mirror the synax for heredocs,
+      the top of a file. Block comments, which mirror the syntax for heredocs,
       are preserved in the generated code.
     </p>
     <div class='code'><pre class="idle"><span class="Comment"><span class="Comment">###</span></span>
-<span class="Comment">CoffeeScript Compiler v1.0.0</span>
+<span class="Comment">CoffeeScript Compiler v1.1.2</span>
 <span class="Comment">Released under the MIT License</span>
 <span class="Comment"><span class="Comment">###</span></span>
 
 
 </pre><pre class="idle"><span class="Comment"><span class="Comment">/*</span></span>
-<span class="Comment">CoffeeScript Compiler v1.0.0</span>
+<span class="Comment">CoffeeScript Compiler v1.1.2</span>
 <span class="Comment">Released under the MIT License</span>
 <span class="Comment"><span class="Comment">*/</span></span>
-</pre><script>window.example37 = "###\nCoffeeScript Compiler v1.0.0\nReleased under the MIT License\n###\n\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example37);'>load</div><br class='clear' /></div>
+</pre><script>window.example37 = "###\nCoffeeScript Compiler v1.1.2\nReleased under the MIT License\n###\n\n\n"</script><div class='minibutton load' onclick='javascript: loadConsole(example37);'>load</div><br class='clear' /></div>
 
     <p>
       <span id="regexes" class="bookmark"></span>
@@ -1811,7 +1824,7 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
 
     <p>
       In fact, the little bit of glue script that runs "Try CoffeeScript" above,
-      as well as jQuery for the menu, is implemented in just this way.
+      as well as the jQuery for the menu, is implemented in just this way.
       View source and look at the bottom of the page to see the example.
       Including the script also gives you access to <tt>CoffeeScript.compile()</tt>
       so you can pop open Firebug and try compiling some strings.
@@ -1829,6 +1842,10 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
     </h2>
 
     <ul>
+      <li>
+        <b>sstephenson</b>'s <a href="http://pow.cx/">Pow</a>,
+        a zero-configuration Rack server, with comprehensive annotated source.
+      </li>
       <li>
         <b>frank06</b>'s <a href="http://riakjs.org/">riak-js</a>, a Node.js client for
         <a href="http://www.basho.com/Riak.html">Riak</a>, with support for HTTP
@@ -1838,6 +1855,10 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
         <b>technoweenie</b>'s <a href="https://github.com/technoweenie/coffee-resque">Coffee-Resque</a>,
         a port of <a href="https://github.com/defunkt/resque">Resque</a> for Node.js.
       </li>
+      <li>
+        <b>assaf</b>'s <a href="http://zombie.labnotes.org/">Zombie.js</a>,
+        A headless, full-stack, faux-browser testing library for Node.js.
+      </li>
       <li>
         <b>jashkenas</b>' <a href="documentation/docs/underscore.html">Underscore.coffee</a>, a port
         of the <a href="http://documentcloud.github.com/underscore/">Underscore.js</a>
@@ -1851,10 +1872,6 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
         <b>josh</b>'s <a href="http://josh.github.com/nack/">nack</a>, a Node.js-powered
         <a href="http://rack.rubyforge.org/">Rack</a> server.
       </li>
-      <li>
-        <b>sstephenson</b>'s <a href="http://sstephenson.github.com/strscan-js/">StringScanner</a>,
-        a simple tokenizer and lexical scanner for JavaScript strings.
-      </li>
     </ul>
 
     <h2>
@@ -1877,103 +1894,23 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
       </li>
       <li>
         <a href="http://github.com/jashkenas/coffee-script/issues">CoffeeScript Issues</a><br />
-        Bugs reports, feature requests, and general discussion all belong here.
+        Bug reports, feature proposals, and ideas for changes to the language belong here.
       </li>
       <li>
-        If you'd like to chat, stop by <tt>#coffeescript</tt> on Freenode in the
-        IRC client of your choice, or on
-        <a href="http://webchat.freenode.net/">webchat.freenode.net</a>.
+        <a href="https://groups.google.com/forum/#!forum/coffeescript">CoffeeScript Google Group</a><br />
+        If you'd like to ask a question, the mailing list is a good place to get help.
       </li>
       <li>
-        <b>satyr</b>'s <a href="http://github.com/satyr/coco">Coco</a>
-        &mdash; An avant-garde dialect of CoffeeScript that frequently pioneers
-        features and optimizations, some of which CoffeeScript later adopts.
-        Check out the <a href="https://github.com/satyr/coco/wiki/additions">list of additions</a>
-        to the language.
+        <a href="http://github.com/jashkenas/coffee-script/wiki">The CoffeeScript Wiki</a><br />
+        If you've ever learned a neat CoffeeScript tip or trick, or ran into a gotcha &mdash; share it on the wiki.
+        The wiki also serves as a directory of handy 
+        <a href="http://github.com/jashkenas/coffee-script/wiki/Text-editor-plugins">text editor extensions</a>,
+        <a href="http://github.com/jashkenas/coffee-script/wiki/Web-framework-plugins">web framework plugins</a>,
+        and general <a href="http://github.com/jashkenas/coffee-script/wiki/Build-tools">CoffeeScript build tools</a>.
       </li>
       <li>
-        <b>yeungda</b>'s <a href="http://github.com/yeungda/jcoffeescript">JCoffeeScript</a>
-        &mdash; A Java Library that uses Rhino to compile CoffeeScript, allowing
-        compilation within Java projects or on systems that Node.js doesn't support.
-      </li>
-      <li>
-        <b>defunkt</b>'s <a href="http://github.com/defunkt/coffee-mode">CoffeeScript Major Mode</a>
-        &mdash; a Emacs major mode that provides syntax highlighting, indentation
-        support, and some bonus commands.
-      </li>
-      <li>
-        <b>jashkenas</b>' <a href="http://github.com/jashkenas/coffee-script-tmbundle">CoffeeScript TextMate Bundle</a>
-        &mdash; which provides syntax highlighting, snippet expansion, and the
-        ability to run bits of CoffeeScript from within TextMate itself.
-      </li>
-      <li>
-        <b>kchmck</b>'s <a href="http://github.com/kchmck/vim-coffee-script">Vim CoffeeScript</a>
-        &mdash; which adds Vim syntax highlighting and indentation support.
-      </li>
-      <li>
-        <b>wavded</b>'s <a href="http://github.com/wavded/gedit-coffeescript">gedit-coffeescript</a>
-        &mdash; a CoffeeScript syntax highlighter for the gedit text editor.
-      </li>
-      <li>
-        <b>yeungda</b>'s <a href="http://yeungda.github.com/coffeescript-idea/">coffeescript-idea</a>
-        &mdash; a plugin for IntelliJ IDEA and RubyMine providing syntax highlighting.
-      </li>
-      <li>
-        <b>mattly</b>'s <a href="http://github.com/mattly/rack-coffee">rack-coffee</a>
-        &mdash; a small Rack middleware for serving CoffeeScript files as
-        compiled JavaScript on the fly.
-      </li>
-      <li>
-        <b>jnicklas</b>'s <a href="http://github.com/jnicklas/bistro_car">BistroCar</a>
-        &mdash; a plugin that serves and bundles CoffeeScript from within your
-        Rails application.
-      </li>
-      <li>
-        <b>dsc</b>'s <a href="http://github.com/dsc/coffeecup">CoffeeCup</a>
-        &mdash; a Python WSGI middleware that compiles CoffeeScript to JavaScript
-        on-demand during development.
-      </li>
-      <li>
-        <b>sutto</b>'s <a href="http://github.com/Sutto/barista">Barista</a>
-        &mdash; a BistroCar alternative that integrates well with
-        <a href="http://documentcloud.github.com/jammit">Jammit</a> and Rails 3.
-      </li>
-      <li>
-        <b>inem</b> and <b>gerad</b>'s <a href="http://github.com/gerad/coffee-haml-filter">coffee-haml-filter</a>
-        &mdash; a custom filter for rendering CoffeeScript inline within
-        <a href="http://haml-lang.com/">HAML</a> templates.
-      </li>
-      <li>
-        <b>chrislloyd</b>'s <a href="http://github.com/chrislloyd/roast">Roast</a>
-        &mdash; a CoffeeScript compiler plug-in that allows you to include external
-        source files.
-      </li>
-      <li>
-        <b>andrzejsliwa</b>'s <a href="http://github.com/andrzejsliwa/coffeeapp">CoffeeApp</a>
-        &mdash; a CoffeeScript wrapper for CouchApps, web applications served
-        directly from CouchDB.
-      </li>
-      <li>
-        <b>sstephenson</b>'s <a href="http://github.com/sstephenson/eco">Eco</a>
-        &mdash; high-performance embedded CoffeeScript templates, after EJS and ERB.
-      </li>
-      <li>
-        <b>mauricemach</b>'s <a href="http://github.com/mauricemach/coffeekup">CoffeeKup</a>
-        &mdash; Markup as CoffeeScript. After _why's
-        <a href="http://markaby.github.com/">Markaby</a>.
-      </li>
-      <li>
-        <b>jashkenas</b>' <a href="http://jashkenas.github.com/docco/">Docco</a>
-        &mdash; a quick-and-dirty literate-programming-style documentation generator
-        for CoffeeScript. Used to produce the annotated source.
-      </li>
-      <li>
-        <b>naturalethic</b>'s <a href="http://github.com/naturalethic/coffee-mongo">coffee-mongo</a>
-        &mdash; an asynchronous MongoDB ORM, for use with Node.js and CoffeeScript.
-      </li>
-      <li>
-        <b>mauricemach</b>'s <a href="https://github.com/mauricemach/zappa">Zappa</a>
-        &mdash; a DSL for building web apps, built on top of Express and Socket.IO.
+        <a href="http://github.com/jashkenas/coffee-script/wiki/FAQ">The FAQ</a><br />
+        Perhaps your CoffeeScript-related question has been asked before. Check the FAQ first.
       </li>
     </ul>
 
@@ -1996,6 +1933,61 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
       <span id="change_log" class="bookmark"></span>
       Change Log
     </h2>
+    
+    <p>
+      <b class="header" style="margin-top: 20px;">
+        <a href="https://github.com/jashkenas/coffee-script/compare/1.1.1...1.1.2">1.1.2</a>
+        <span class="timestamp"> &ndash; <small>August 4, 2011</small></span>
+      </b>
+      We now use the native <tt>Function.prototype.bind</tt> for bound function
+      literals where available.
+      Fixes for: block comment formatting, <tt>?=</tt> compilation, implicit calls
+      against control structures, implicit invocation of a try/catch block,
+      variadic arguments leaking from local scope, line numbers in syntax errors
+      following heregexes, property access on parenthesized number literals,
+      bound class methods and super with reserved names, a REPL overhaul, 
+      consecutive compiled semicolons, block comments in implicitly called objects,
+      and a Chrome bug.
+    </p>
+    
+    <p>
+      <b class="header" style="margin-top: 20px;">1.1.1
+        <span class="timestamp"> &ndash; <small>May 10, 2011</small></span>
+      </b>
+      Bugfix release for classes with external constructor functions, see 
+      issue #1182.
+    </p>
+    
+    <p>
+      <b class="header" style="margin-top: 20px;">1.1.0
+        <span class="timestamp"> &ndash; <small>May 1, 2011</small></span>
+      </b>
+      When running via the <tt>coffee</tt> executable, <tt>process.argv</tt> and 
+      friends now report <tt>coffee</tt> instead of <tt>node</tt>.
+      Better compatibility with <b>Node.js 0.4.x</b> module lookup changes.
+      The output in the REPL is now colorized, like Node's is.
+      Giving your concatenated CoffeeScripts a name when using <tt>--join</tt> is now mandatory.
+      Fix for lexing compound division <tt>/=</tt> as a regex accidentally.
+      All <tt>text/coffeescript</tt> tags should now execute in the order they're included.
+      Fixed an issue with extended subclasses using external constructor functions.
+      Fixed an edge-case infinite loop in <tt>addImplicitParentheses</tt>.
+      Fixed exponential slowdown with long chains of function calls.
+      Globals no longer leak into the CoffeeScript REPL.
+      Splatted parameters are declared local to the function.
+    </p>
+
+    <p>
+      <b class="header" style="margin-top: 20px;">1.0.1
+        <span class="timestamp"> &ndash; <small>Jan 31, 2011</small></span>
+      </b>
+      Fixed a lexer bug with Unicode identifiers. Updated REPL for compatibility
+      with Node.js 0.3.7. Fixed requiring relative paths in the REPL. Trailing
+      <tt>return</tt> and <tt>return undefined</tt> are now optimized away.
+      Stopped requiring the core Node.js <tt>"util"</tt> module for
+      back-compatibility with Node.js 0.2.5. Fixed a case where a
+      conditional <tt>return</tt> would cause fallthrough in a <tt>switch</tt>
+      statement. Optimized empty objects in destructuring assignment.
+    </p>
 
     <p>
       <b class="header" style="margin-top: 20px;">1.0.0
@@ -2470,7 +2462,7 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
     $('#repl_source').keyup -> compileSource()
 
     # Eval the compiled js.
-    $('.minibutton.run').click ->
+    evalJS = ->
       try
         eval window.compiledJS
       catch error then alert error
@@ -2486,6 +2478,8 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
     closeMenus = ->
       $('.navigation.active').removeClass 'active'
 
+    $('.minibutton.run').click evalJS
+
     # Bind navigation buttons to open the menus.
     $('.navigation').click (e) ->
       return if e.target.tagName.toLowerCase() is 'a'
@@ -2497,9 +2491,15 @@ task(<span class="String"><span class="String">'</span>build:parser<span class="
         $(this).addClass 'active'
       false
 
-    $(document.body).click (e) ->
-      return false if $(e.target).hasClass('minibutton')
-      closeMenus()
+    # Dismiss console if Escape pressed or click falls outside console
+    # Trigger Run button on Ctrl-Enter
+    $(document.body)
+      .keydown (e) ->
+        closeMenus() if e.which == 27
+        evalJS() if e.which == 13 and (e.metaKey or e.ctrlKey) and $('.minibutton.run:visible').length
+      .click (e) ->
+        return false if $(e.target).hasClass('minibutton')
+        closeMenus()
 
     $('#open_webchat').click ->
       $(this).replaceWith $('<iframe src="http://webchat.freenode.net/?channels=coffeescript" width="625" height="400"></iframe>')

lib/browser.js

@@ -12,10 +12,10 @@
     options.bare = true;
     return Function(CoffeeScript.compile(code, options))();
   };
-  if (typeof window == "undefined" || window === null) {
+  if (typeof window === "undefined" || window === null) {
     return;
   }
-  CoffeeScript.load = function(url, options) {
+  CoffeeScript.load = function(url, callback) {
     var xhr;
     xhr = new (window.ActiveXObject || XMLHttpRequest)('Microsoft.XMLHTTP');
     xhr.open('GET', url, true);
@@ -23,25 +23,48 @@
       xhr.overrideMimeType('text/plain');
     }
     xhr.onreadystatechange = function() {
+      var _ref;
       if (xhr.readyState === 4) {
-        return CoffeeScript.run(xhr.responseText, options);
+        if ((_ref = xhr.status) === 0 || _ref === 200) {
+          CoffeeScript.run(xhr.responseText);
+        } else {
+          throw new Error("Could not load " + url);
+        }
+        if (callback) {
+          return callback();
+        }
       }
     };
     return xhr.send(null);
   };
   runScripts = function() {
-    var script, _i, _len, _ref;
-    _ref = document.getElementsByTagName('script');
-    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-      script = _ref[_i];
-      if (script.type === 'text/coffeescript') {
-        if (script.src) {
-          CoffeeScript.load(script.src);
-        } else {
-          CoffeeScript.run(script.innerHTML);
+    var coffees, execute, index, length, s, scripts;
+    scripts = document.getElementsByTagName('script');
+    coffees = (function() {
+      var _i, _len, _results;
+      _results = [];
+      for (_i = 0, _len = scripts.length; _i < _len; _i++) {
+        s = scripts[_i];
+        if (s.type === 'text/coffeescript') {
+          _results.push(s);
         }
       }
-    }
+      return _results;
+    })();
+    index = 0;
+    length = coffees.length;
+    (execute = function() {
+      var script;
+      script = coffees[index++];
+      if ((script != null ? script.type : void 0) === 'text/coffeescript') {
+        if (script.src) {
+          return CoffeeScript.load(script.src, execute);
+        } else {
+          CoffeeScript.run(script.innerHTML);
+          return execute();
+        }
+      }
+    })();
     return null;
   };
   if (window.addEventListener) {

lib/cake.js

@@ -39,7 +39,7 @@
       }
       args = process.argv.slice(2);
       CoffeeScript.run(fs.readFileSync('Cakefile').toString(), {
-        fileName: 'Cakefile'
+        filename: 'Cakefile'
       });
       oparse = new optparse.OptionParser(switches);
       if (!args.length) {

lib/coffee-script.js

@@ -1,5 +1,6 @@
 (function() {
   var Lexer, RESERVED, compile, fs, lexer, parser, path, _ref;
+  var __hasProp = Object.prototype.hasOwnProperty;
   fs = require('fs');
   path = require('path');
   _ref = require('./lexer'), Lexer = _ref.Lexer, RESERVED = _ref.RESERVED;
@@ -7,7 +8,9 @@
   if (require.extensions) {
     require.extensions['.coffee'] = function(module, filename) {
       var content;
-      content = compile(fs.readFileSync(filename, 'utf8'));
+      content = compile(fs.readFileSync(filename, 'utf8'), {
+        filename: filename
+      });
       return module._compile(content, filename);
     };
   } else if (require.registerExtension) {
@@ -15,7 +18,7 @@
       return compile(content);
     });
   }
-  exports.VERSION = '1.0.0';
+  exports.VERSION = '1.1.2';
   exports.RESERVED = RESERVED;
   exports.helpers = require('./helpers');
   exports.compile = compile = function(code, options) {
@@ -25,8 +28,8 @@
     try {
       return (parser.parse(lexer.tokenize(code))).compile(options);
     } catch (err) {
-      if (options.fileName) {
-        err.message = "In " + options.fileName + ", " + err.message;
+      if (options.filename) {
+        err.message = "In " + options.filename + ", " + err.message;
       }
       throw err;
     }
@@ -42,32 +45,82 @@
     }
   };
   exports.run = function(code, options) {
-    var root;
-    root = module;
-    while (root.parent) {
-      root = root.parent;
+    var Module, mainModule;
+    mainModule = require.main;
+    mainModule.filename = process.argv[1] = options.filename ? fs.realpathSync(options.filename) : '.';
+    mainModule.moduleCache && (mainModule.moduleCache = {});
+    if (process.binding('natives').module) {
+      Module = require('module').Module;
+      mainModule.paths = Module._nodeModulePaths(path.dirname(options.filename));
     }
-    root.filename = fs.realpathSync(options.fileName || '.');
-    if (root.moduleCache) {
-      root.moduleCache = {};
-    }
-    if (path.extname(root.filename) !== '.coffee' || require.extensions) {
-      return root._compile(compile(code, options), root.filename);
+    if (path.extname(mainModule.filename) !== '.coffee' || require.extensions) {
+      return mainModule._compile(compile(code, options), mainModule.filename);
     } else {
-      return root._compile(code, root.filename);
+      return mainModule._compile(code, mainModule.filename);
     }
   };
   exports.eval = function(code, options) {
-    var __dirname, __filename;
-    __filename = options.fileName;
-    __dirname = path.dirname(__filename);
-    return eval(compile(code, options));
+    var Module, Script, js, k, o, r, sandbox, v, _i, _len, _module, _ref2, _ref3, _ref4, _require;
+    if (options == null) {
+      options = {};
+    }
+    if (!(code = code.trim())) {
+      return;
+    }
+    if (_ref2 = require('vm'), Script = _ref2.Script, _ref2) {
+      sandbox = Script.createContext();
+      sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox;
+      if (options.sandbox != null) {
+        if (options.sandbox instanceof sandbox.constructor) {
+          sandbox = options.sandbox;
+        } else {
+          _ref3 = options.sandbox;
+          for (k in _ref3) {
+            if (!__hasProp.call(_ref3, k)) continue;
+            v = _ref3[k];
+            sandbox[k] = v;
+          }
+        }
+      }
+      sandbox.__filename = options.filename || 'eval';
+      sandbox.__dirname = path.dirname(sandbox.__filename);
+      if (!(sandbox.module || sandbox.require)) {
+        Module = require('module');
+        sandbox.module = _module = new Module(options.modulename || 'eval');
+        sandbox.require = _require = function(path) {
+          return Module._load(path, _module);
+        };
+        _module.filename = sandbox.__filename;
+        _ref4 = Object.getOwnPropertyNames(require);
+        for (_i = 0, _len = _ref4.length; _i < _len; _i++) {
+          r = _ref4[_i];
+          _require[r] = require[r];
+        }
+        _require.paths = _module.paths = Module._nodeModulePaths(process.cwd());
+        _require.resolve = function(request) {
+          return Module._resolveFilename(request, _module);
+        };
+      }
+    }
+    o = {};
+    for (k in options) {
+      if (!__hasProp.call(options, k)) continue;
+      v = options[k];
+      o[k] = v;
+    }
+    o.bare = true;
+    js = compile(code, o);
+    if (Script) {
+      return Script.runInContext(js, sandbox);
+    } else {
+      return eval(js);
+    }
   };
   lexer = new Lexer;
   parser.lexer = {
     lex: function() {
-      var tag, _ref;
-      _ref = this.tokens[this.pos++] || [''], tag = _ref[0], this.yytext = _ref[1], this.yylineno = _ref[2];
+      var tag, _ref2;
+      _ref2 = this.tokens[this.pos++] || [''], tag = _ref2[0], this.yytext = _ref2[1], this.yylineno = _ref2[2];
       return tag;
     },
     setInput: function(tokens) {

lib/command.js

@@ -1,8 +1,7 @@
 (function() {
-  var BANNER, CoffeeScript, EventEmitter, SWITCHES, compileJoin, compileOptions, compileScript, compileScripts, compileStdio, contents, exec, forkNode, fs, helpers, lint, optionParser, optparse, opts, parseOptions, path, printLine, printTokens, printWarn, sources, spawn, usage, util, version, watch, writeJs, _ref;
+  var BANNER, CoffeeScript, EventEmitter, SWITCHES, compileJoin, compileOptions, compileScript, compileScripts, compileStdio, contents, exec, forkNode, fs, helpers, lint, loadRequires, optionParser, optparse, opts, parseOptions, path, printLine, printTokens, printWarn, sources, spawn, usage, version, watch, writeJs, _ref;
   fs = require('fs');
   path = require('path');
-  util = require('util');
   helpers = require('./helpers');
   optparse = require('./optparse');
   CoffeeScript = require('./coffee-script');
@@ -16,7 +15,7 @@
     return process.binding('stdio').writeError(line + '\n');
   };
   BANNER = 'Usage: coffee [options] path/to/script.coffee';
-  SWITCHES = [['-c', '--compile', 'compile to JavaScript and save as .js files'], ['-i', '--interactive', 'run an interactive CoffeeScript REPL'], ['-o', '--output [DIR]', 'set the directory for compiled JavaScript'], ['-j', '--join', 'concatenate the scripts before compiling'], ['-w', '--watch', 'watch scripts for changes, and recompile'], ['-p', '--print', 'print the compiled JavaScript to stdout'], ['-l', '--lint', 'pipe the compiled JavaScript through JSLint'], ['-s', '--stdio', 'listen for and compile scripts over stdio'], ['-e', '--eval', 'compile a string from the command line'], ['-r', '--require [FILE*]', 'require a library before executing your script'], ['-b', '--bare', 'compile without the top-level function wrapper'], ['-t', '--tokens', 'print the tokens that the lexer produces'], ['-n', '--nodes', 'print the parse tree that Jison produces'], ['--nodejs [ARGS]', 'pass options through to the "node" binary'], ['-v', '--version', 'display CoffeeScript version'], ['-h', '--help', 'display this help message']];
+  SWITCHES = [['-c', '--compile', 'compile to JavaScript and save as .js files'], ['-i', '--interactive', 'run an interactive CoffeeScript REPL'], ['-o', '--output [DIR]', 'set the directory for compiled JavaScript'], ['-j', '--join [FILE]', 'concatenate the scripts before compiling'], ['-w', '--watch', 'watch scripts for changes, and recompile'], ['-p', '--print', 'print the compiled JavaScript to stdout'], ['-l', '--lint', 'pipe the compiled JavaScript through JavaScript Lint'], ['-s', '--stdio', 'listen for and compile scripts over stdio'], ['-e', '--eval', 'compile a string from the command line'], ['-r', '--require [FILE*]', 'require a library before executing your script'], ['-b', '--bare', 'compile without the top-level function wrapper'], ['-t', '--tokens', 'print the tokens that the lexer produces'], ['-n', '--nodes', 'print the parse tree that Jison produces'], ['--nodejs [ARGS]', 'pass options through to the "node" binary'], ['-v', '--version', 'display CoffeeScript version'], ['-h', '--help', 'display this help message']];
   opts = {};
   sources = [];
   contents = [];
@@ -32,6 +31,9 @@
     if (opts.version) {
       return version();
     }
+    if (opts.require) {
+      loadRequires();
+    }
     if (opts.interactive) {
       return require('./repl');
     }
@@ -48,35 +50,65 @@
       opts.literals = sources.splice(1).concat(opts.literals);
     }
     process.ARGV = process.argv = process.argv.slice(0, 2).concat(opts.literals);
+    process.argv[0] = 'coffee';
+    process.execPath = require.main.filename;
     return compileScripts();
   };
   compileScripts = function() {
-    var base, compile, source, _i, _len, _results;
-    _results = [];
+    var base, compile, source, unprocessed, _i, _j, _len, _len2, _results;
+    unprocessed = [];
     for (_i = 0, _len = sources.length; _i < _len; _i++) {
       source = sources[_i];
+      unprocessed[sources.indexOf(source)] = 1;
+    }
+    _results = [];
+    for (_j = 0, _len2 = sources.length; _j < _len2; _j++) {
+      source = sources[_j];
       base = path.join(source);
-      compile = function(source, topLevel) {
+      compile = function(source, sourceIndex, topLevel) {
+        var remaining_files;
+        remaining_files = function() {
+          var total, x, _k, _len3;
+          total = 0;
+          for (_k = 0, _len3 = unprocessed.length; _k < _len3; _k++) {
+            x = unprocessed[_k];
+            total += x;
+          }
+          return total;
+        };
         return path.exists(source, function(exists) {
-          if (!exists) {
+          if (topLevel && !exists && source.slice(-7) !== '.coffee') {
+            return compile("" + source + ".coffee", sourceIndex, topLevel);
+          }
+          if (topLevel && !exists) {
             throw new Error("File not found: " + source);
           }
           return fs.stat(source, function(err, stats) {
+            if (err) {
+              throw err;
+            }
             if (stats.isDirectory()) {
               return fs.readdir(source, function(err, files) {
-                var file, _i, _len, _results;
-                _results = [];
-                for (_i = 0, _len = files.length; _i < _len; _i++) {
-                  file = files[_i];
-                  _results.push(compile(path.join(source, file)));
+                var file, _k, _len3;
+                if (err) {
+                  throw err;
                 }
-                return _results;
+                unprocessed[sourceIndex] += files.length;
+                for (_k = 0, _len3 = files.length; _k < _len3; _k++) {
+                  file = files[_k];
+                  compile(path.join(source, file), sourceIndex);
+                }
+                return unprocessed[sourceIndex] -= 1;
               });
             } else if (topLevel || path.extname(source) === '.coffee') {
               fs.readFile(source, function(err, code) {
+                if (err) {
+                  throw err;
+                }
+                unprocessed[sourceIndex] -= 1;
                 if (opts.join) {
-                  contents[sources.indexOf(source)] = code.toString();
-                  if (helpers.compact(contents).length === sources.length) {
+                  contents[sourceIndex] = helpers.compact([contents[sourceIndex], code.toString()]).join('\n');
+                  if (helpers.compact(contents).length > 0 && remaining_files() === 0) {
                     return compileJoin();
                   }
                 } else {
@@ -86,25 +118,20 @@
               if (opts.watch && !opts.join) {
                 return watch(source, base);
               }
+            } else {
+              return unprocessed[sourceIndex] -= 1;
             }
           });
         });
       };
-      _results.push(compile(source, true));
+      _results.push(compile(source, sources.indexOf(source), true));
     }
     return _results;
   };
   compileScript = function(file, input, base) {
-    var o, options, req, t, task, _i, _len, _ref;
+    var o, options, t, task;
     o = opts;
     options = compileOptions(file);
-    if (o.require) {
-      _ref = o.require;
-      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-        req = _ref[_i];
-        require(helpers.starts(req, '.') ? fs.realpathSync(req) : req);
-      }
-    }
     try {
       t = task = {
         file: file,
@@ -157,7 +184,18 @@
   compileJoin = function() {
     var code;
     code = contents.join('\n');
-    return compileScript("concatenation", code, "concatenation");
+    return compileScript(opts.join, code, opts.join);
+  };
+  loadRequires = function() {
+    var realFilename, req, _i, _len, _ref2;
+    realFilename = module.filename;
+    module.filename = '.';
+    _ref2 = opts.require;
+    for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+      req = _ref2[_i];
+      require(req);
+    }
+    return module.filename = realFilename;
   };
   watch = function(source, base) {
     return fs.watchFile(source, {
@@ -190,7 +228,7 @@
         if (err) {
           return printLine(err.message);
         } else if (opts.compile && opts.watch) {
-          return util.log("compiled " + source);
+          return console.log("" + ((new Date).toLocaleTimeString()) + " - compiled " + source);
         }
       });
     };
@@ -217,11 +255,11 @@
   printTokens = function(tokens) {
     var strings, tag, token, value;
     strings = (function() {
-      var _i, _len, _ref, _results;
+      var _i, _len, _ref2, _results;
       _results = [];
       for (_i = 0, _len = tokens.length; _i < _len; _i++) {
         token = tokens[_i];
-        _ref = [token[0], token[1].toString().replace(/\n/, '\\n')], tag = _ref[0], value = _ref[1];
+        _ref2 = [token[0], token[1].toString().replace(/\n/, '\\n')], tag = _ref2[0], value = _ref2[1];
         _results.push("[" + tag + " " + value + "]");
       }
       return _results;
@@ -237,9 +275,9 @@
     o.print = !!(o.print || (o.eval || o.stdio && o.compile));
     return sources = o.arguments;
   };
-  compileOptions = function(fileName) {
+  compileOptions = function(filename) {
     return {
-      fileName: fileName,
+      filename: filename,
       bare: opts.bare
     };
   };
@@ -255,11 +293,9 @@
     });
   };
   usage = function() {
-    printLine((new optparse.OptionParser(SWITCHES, BANNER)).help());
-    return process.exit(0);
+    return printLine((new optparse.OptionParser(SWITCHES, BANNER)).help());
   };
   version = function() {
-    printLine("CoffeeScript version " + CoffeeScript.VERSION);
-    return process.exit(0);
+    return printLine("CoffeeScript version " + CoffeeScript.VERSION);
   };
 }).call(this);

lib/grammar.js

@@ -10,18 +10,18 @@
     }
     action = (match = unwrap.exec(action)) ? match[1] : "(" + action + "())";
     action = action.replace(/\bnew /g, '$&yy.');
-    action = action.replace(/\b(?:Expressions\.wrap|extend)\b/g, 'yy.$&');
+    action = action.replace(/\b(?:Block\.wrap|extend)\b/g, 'yy.$&');
     return [patternString, "$$ = " + action + ";", options];
   };
   grammar = {
     Root: [
       o('', function() {
-        return new Expressions;
+        return new Block;
       }), o('Body'), o('Block TERMINATOR')
     ],
     Body: [
       o('Line', function() {
-        return Expressions.wrap([$1]);
+        return Block.wrap([$1]);
       }), o('Body TERMINATOR Line', function() {
         return $1.push($3);
       }), o('Body TERMINATOR')
@@ -35,7 +35,7 @@
     Expression: [o('Value'), o('Invocation'), o('Code'), o('Operation'), o('Assign'), o('If'), o('Try'), o('While'), o('For'), o('Switch'), o('Class')],
     Block: [
       o('INDENT OUTDENT', function() {
-        return new Expressions;
+        return new Block;
       }), o('INDENT Body OUTDENT', function() {
         return $2;
       })
@@ -58,7 +58,12 @@
       }), o('REGEX', function() {
         return new Literal($1);
       }), o('BOOL', function() {
-        return new Literal($1 === 'undefined' ? 'void 0' : $1);
+        var val;
+        val = new Literal($1);
+        if ($1 === 'undefined') {
+          val.isUndefined = true;
+        }
+        return val;
       })
     ],
     Assign: [
@@ -164,13 +169,11 @@
         return new Access($2, 'proto');
       }), o('::', function() {
         return new Access(new Literal('prototype'));
-      }), o('Index'), o('Slice', function() {
-        return new Slice($1);
-      })
+      }), o('Index')
     ],
     Index: [
-      o('INDEX_START Expression INDEX_END', function() {
-        return new Index($2);
+      o('INDEX_START IndexValue INDEX_END', function() {
+        return $2;
       }), o('INDEX_SOAK  Index', function() {
         return extend($2, {
           soak: true
@@ -181,6 +184,13 @@
         });
       })
     ],
+    IndexValue: [
+      o('Expression', function() {
+        return new Index($1);
+      }), o('Slice', function() {
+        return new Slice($1);
+      })
+    ],
     Object: [
       o('{ AssignList OptComma }', function() {
         return new Obj($2, $1.generated);
@@ -275,12 +285,12 @@
       })
     ],
     Slice: [
-      o('INDEX_START Expression RangeDots Expression INDEX_END', function() {
-        return new Range($2, $4, $3);
-      }), o('INDEX_START Expression RangeDots INDEX_END', function() {
-        return new Range($2, null, $3);
-      }), o('INDEX_START RangeDots Expression INDEX_END', function() {
-        return new Range(null, $3, $2);
+      o('Expression RangeDots Expression', function() {
+        return new Range($1, $3, $2);
+      }), o('Expression RangeDots', function() {
+        return new Range($1, null, $2);
+      }), o('RangeDots Expression', function() {
+        return new Range(null, $2, $1);
       })
     ],
     ArgList: [
@@ -352,9 +362,9 @@
       o('WhileSource Block', function() {
         return $1.addBody($2);
       }), o('Statement  WhileSource', function() {
-        return $2.addBody(Expressions.wrap([$1]));
+        return $2.addBody(Block.wrap([$1]));
       }), o('Expression WhileSource', function() {
-        return $2.addBody(Expressions.wrap([$1]));
+        return $2.addBody(Block.wrap([$1]));
       }), o('Loop', function() {
         return $1;
       })
@@ -363,7 +373,7 @@
       o('LOOP Block', function() {
         return new While(new Literal('true')).addBody($2);
       }), o('LOOP Expression', function() {
-        return new While(new Literal('true')).addBody(Expressions.wrap([$2]));
+        return new While(new Literal('true')).addBody(Block.wrap([$2]));
       })
     ],
     For: [
@@ -481,18 +491,18 @@
         return $1.addElse(new If($4, $5, {
           type: $3
         }));
-      }), o('IfBlock ELSE Block', function() {
-        return $1.addElse($3);
       })
     ],
     If: [
-      o('IfBlock'), o('Statement  POST_IF Expression', function() {
-        return new If($3, Expressions.wrap([$1]), {
+      o('IfBlock'), o('IfBlock ELSE Block', function() {
+        return $1.addElse($3);
+      }), o('Statement  POST_IF Expression', function() {
+        return new If($3, Block.wrap([$1]), {
           type: $2,
           statement: true
         });
       }), o('Expression POST_IF Expression', function() {
-        return new If($3, Expressions.wrap([$1]), {
+        return new If($3, Block.wrap([$1]), {
           type: $2,
           statement: true
         });

lib/lexer.js

@@ -1,5 +1,5 @@
 (function() {
-  var ASSIGNED, BOOL, CALLABLE, CODE, COFFEE_ALIASES, COFFEE_KEYWORDS, COMMENT, COMPARE, COMPOUND_ASSIGN, HEREDOC, HEREDOC_INDENT, HEREGEX, HEREGEX_OMIT, IDENTIFIER, INDEXABLE, JSTOKEN, JS_FORBIDDEN, JS_KEYWORDS, LINE_BREAK, LINE_CONTINUER, LOGIC, Lexer, MATH, MULTILINER, MULTI_DENT, NOT_REGEX, NOT_SPACED_REGEX, NO_NEWLINE, NUMBER, OPERATOR, REGEX, RELATION, RESERVED, Rewriter, SHIFT, SIMPLESTR, TRAILING_SPACES, UNARY, WHITESPACE, compact, count, last, op, starts, _ref;
+  var ASSIGNED, BOOL, CALLABLE, CODE, COFFEE_ALIASES, COFFEE_ALIAS_MAP, COFFEE_KEYWORDS, COMMENT, COMPARE, COMPOUND_ASSIGN, HEREDOC, HEREDOC_ILLEGAL, HEREDOC_INDENT, HEREGEX, HEREGEX_OMIT, IDENTIFIER, INDEXABLE, JSTOKEN, JS_FORBIDDEN, JS_KEYWORDS, LINE_BREAK, LINE_CONTINUER, LOGIC, Lexer, MATH, MULTILINER, MULTI_DENT, NOT_REGEX, NOT_SPACED_REGEX, NO_NEWLINE, NUMBER, OPERATOR, REGEX, RELATION, RESERVED, Rewriter, SHIFT, SIMPLESTR, TRAILING_SPACES, UNARY, WHITESPACE, compact, count, key, last, starts, _ref;
   var __indexOf = Array.prototype.indexOf || function(item) {
     for (var i = 0, l = this.length; i < l; i++) {
       if (this[i] === item) return i;
@@ -15,6 +15,9 @@
       if (opts == null) {
         opts = {};
       }
+      if (WHITESPACE.test(code)) {
+        code = "\n" + code;
+      }
       code = code.replace(/\r/g, '').replace(TRAILING_SPACES, '');
       this.code = code;
       this.line = opts.line || 0;
@@ -34,7 +37,7 @@
       return (new Rewriter).rewrite(this.tokens);
     };
     Lexer.prototype.identifierToken = function() {
-      var colon, forcedIdentifier, id, input, match, prev, tag, _ref, _ref2;
+      var colon, forcedIdentifier, id, input, match, prev, tag, _ref2, _ref3;
       if (!(match = IDENTIFIER.exec(this.chunk))) {
         return 0;
       }
@@ -43,11 +46,11 @@
         this.token('OWN', id);
         return id.length;
       }
-      forcedIdentifier = colon || (prev = last(this.tokens)) && !prev.spaced && ((_ref = prev[0]) === '.' || _ref === '?.' || _ref === '@' || _ref === '::');
+      forcedIdentifier = colon || (prev = last(this.tokens)) && (((_ref2 = prev[0]) === '.' || _ref2 === '?.' || _ref2 === '::') || !prev.spaced && prev[0] === '@');
       tag = 'IDENTIFIER';
-      if (__indexOf.call(JS_KEYWORDS, id) >= 0 || !forcedIdentifier && __indexOf.call(COFFEE_KEYWORDS, id) >= 0) {
+      if (!forcedIdentifier && (__indexOf.call(JS_KEYWORDS, id) >= 0 || __indexOf.call(COFFEE_KEYWORDS, id) >= 0)) {
         tag = id.toUpperCase();
-        if (tag === 'WHEN' && (_ref2 = this.tag(), __indexOf.call(LINE_BREAK, _ref2) >= 0)) {
+        if (tag === 'WHEN' && (_ref3 = this.tag(), __indexOf.call(LINE_BREAK, _ref3) >= 0)) {
           tag = 'LEADING_WHEN';
         } else if (tag === 'FOR') {
           this.seenFor = true;
@@ -78,8 +81,8 @@
         }
       }
       if (!forcedIdentifier) {
-        if (COFFEE_ALIASES.hasOwnProperty(id)) {
-          id = COFFEE_ALIASES[id];
+        if (__indexOf.call(COFFEE_ALIASES, id) >= 0) {
+          id = COFFEE_ALIAS_MAP[id];
         }
         tag = (function() {
           switch (id) {
@@ -172,7 +175,6 @@
         return 0;
       }
       comment = match[0], here = match[1];
-      this.line += count(comment, '\n');
       if (here) {
         this.token('HERECOMMENT', this.sanitizeHeredoc(here, {
           herecomment: true,
@@ -180,6 +182,7 @@
         }));
         this.token('TERMINATOR', '\n');
       }
+      this.line += count(comment, '\n');
       return comment.length;
     };
     Lexer.prototype.jsToken = function() {
@@ -191,15 +194,17 @@
       return script.length;
     };
     Lexer.prototype.regexToken = function() {
-      var match, prev, regex, _ref;
+      var length, match, prev, regex, _ref2;
       if (this.chunk.charAt(0) !== '/') {
         return 0;
       }
       if (match = HEREGEX.exec(this.chunk)) {
-        return this.heregexToken(match);
+        length = this.heregexToken(match);
+        this.line += count(match[0], '\n');
+        return length;
       }
       prev = last(this.tokens);
-      if (prev && (_ref = prev[0], __indexOf.call((prev.spaced ? NOT_REGEX : NOT_SPACED_REGEX), _ref) >= 0)) {
+      if (prev && (_ref2 = prev[0], __indexOf.call((prev.spaced ? NOT_REGEX : NOT_SPACED_REGEX), _ref2) >= 0)) {
         return 0;
       }
       if (!(match = REGEX.exec(this.chunk))) {
@@ -210,7 +215,7 @@
       return regex.length;
     };
     Lexer.prototype.heregexToken = function(match) {
-      var body, flags, heregex, re, tag, tokens, value, _i, _len, _ref, _ref2, _ref3, _ref4;
+      var body, flags, heregex, re, tag, tokens, value, _i, _len, _ref2, _ref3, _ref4, _ref5;
       heregex = match[0], body = match[1], flags = match[2];
       if (0 > body.indexOf('#{')) {
         re = body.replace(HEREGEX_OMIT, '').replace(/\//g, '\\/');
@@ -220,11 +225,11 @@
       this.token('IDENTIFIER', 'RegExp');
       this.tokens.push(['CALL_START', '(']);
       tokens = [];
-      _ref = this.interpolateString(body, {
+      _ref2 = this.interpolateString(body, {
         regex: true
       });
-      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-        _ref2 = _ref[_i], tag = _ref2[0], value = _ref2[1];
+      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+        _ref3 = _ref2[_i], tag = _ref3[0], value = _ref3[1];
         if (tag === 'TOKENS') {
           tokens.push.apply(tokens, value);
         } else {
@@ -237,10 +242,10 @@
         tokens.push(['+', '+']);
       }
       tokens.pop();
-      if (((_ref3 = tokens[0]) != null ? _ref3[0] : void 0) !== 'STRING') {
+      if (((_ref4 = tokens[0]) != null ? _ref4[0] : void 0) !== 'STRING') {
         this.tokens.push(['STRING', '""'], ['+', '+']);
       }
-      (_ref4 = this.tokens).push.apply(_ref4, tokens);
+      (_ref5 = this.tokens).push.apply(_ref5, tokens);
       if (flags) {
         this.tokens.push([',', ','], ['STRING', '"' + flags + '"']);
       }
@@ -337,7 +342,7 @@
       return this;
     };
     Lexer.prototype.literalToken = function() {
-      var match, prev, tag, value, _ref, _ref2, _ref3, _ref4;
+      var match, prev, tag, value, _ref2, _ref3, _ref4, _ref5;
       if (match = OPERATOR.exec(this.chunk)) {
         value = match[0];
         if (CODE.test(value)) {
@@ -349,10 +354,10 @@
       tag = value;
       prev = last(this.tokens);
       if (value === '=' && prev) {
-        if (!prev[1].reserved && (_ref = prev[1], __indexOf.call(JS_FORBIDDEN, _ref) >= 0)) {
+        if (!prev[1].reserved && (_ref2 = prev[1], __indexOf.call(JS_FORBIDDEN, _ref2) >= 0)) {
           this.assignmentError();
         }
-        if ((_ref2 = prev[1]) === '||' || _ref2 === '&&') {
+        if ((_ref3 = prev[1]) === '||' || _ref3 === '&&') {
           prev[0] = 'COMPOUND_ASSIGN';
           prev[1] += '=';
           return value.length;
@@ -373,12 +378,12 @@
       } else if (__indexOf.call(LOGIC, value) >= 0 || value === '?' && (prev != null ? prev.spaced : void 0)) {
         tag = 'LOGIC';
       } else if (prev && !prev.spaced) {
-        if (value === '(' && (_ref3 = prev[0], __indexOf.call(CALLABLE, _ref3) >= 0)) {
+        if (value === '(' && (_ref4 = prev[0], __indexOf.call(CALLABLE, _ref4) >= 0)) {
           if (prev[0] === '?') {
             prev[0] = 'FUNC_EXIST';
           }
           tag = 'CALL_START';
-        } else if (value === '[' && (_ref4 = prev[0], __indexOf.call(INDEXABLE, _ref4) >= 0)) {
+        } else if (value === '[' && (_ref5 = prev[0], __indexOf.call(INDEXABLE, _ref5) >= 0)) {
           tag = 'INDEX_START';
           switch (prev[0]) {
             case '?':
@@ -393,15 +398,19 @@
       return value.length;
     };
     Lexer.prototype.sanitizeHeredoc = function(doc, options) {
-      var attempt, herecomment, indent, match, _ref;
+      var attempt, herecomment, indent, match, _ref2;
       indent = options.indent, herecomment = options.herecomment;
-      if (herecomment && 0 > doc.indexOf('\n')) {
-        return doc;
-      }
-      if (!herecomment) {
+      if (herecomment) {
+        if (HEREDOC_ILLEGAL.test(doc)) {
+          throw new Error("block comment cannot contain \"*/\", starting on line " + (this.line + 1));
+        }
+        if (doc.indexOf('\n') <= 0) {
+          return doc;
+        }
+      } else {
         while (match = HEREDOC_INDENT.exec(doc)) {
           attempt = match[1];
-          if (indent === null || (0 < (_ref = attempt.length) && _ref < indent.length)) {
+          if (indent === null || (0 < (_ref2 = attempt.length) && _ref2 < indent.length)) {
             indent = attempt;
           }
         }
@@ -432,9 +441,11 @@
           case 'CALL_START':
             if (stack.length) {
               stack.pop();
-            } else {
+            } else if (tok[0] === '(') {
               tok[0] = 'PARAM_START';
               return this;
+            } else {
+              return this;
             }
         }
       }
@@ -450,9 +461,9 @@
       throw SyntaxError("Reserved word \"" + (this.value()) + "\" on line " + (this.line + 1) + " can't be assigned");
     };
     Lexer.prototype.balancedString = function(str, end) {
-      var i, letter, prev, stack, _ref;
+      var i, letter, match, prev, stack, _ref2;
       stack = [end];
-      for (i = 1, _ref = str.length; (1 <= _ref ? i < _ref : i > _ref); (1 <= _ref ? i += 1 : i -= 1)) {
+      for (i = 1, _ref2 = str.length; 1 <= _ref2 ? i < _ref2 : i > _ref2; 1 <= _ref2 ? i++ : i--) {
         switch (letter = str.charAt(i)) {
           case '\\':
             i++;
@@ -467,6 +478,8 @@
         }
         if (end === '}' && (letter === '"' || letter === "'")) {
           stack.push(end = letter);
+        } else if (end === '}' && letter === '/' && (match = HEREGEX.exec(str.slice(i)) || REGEX.exec(str.slice(i)))) {
+          i += match[0].length - 1;
         } else if (end === '}' && letter === '{') {
           stack.push(end = '}');
         } else if (end === '"' && prev === '#' && letter === '{') {
@@ -477,7 +490,7 @@
       throw new Error("missing " + (stack.pop()) + ", starting on line " + (this.line + 1));
     };
     Lexer.prototype.interpolateString = function(str, options) {
-      var expr, heredoc, i, inner, interpolated, letter, nested, pi, regex, tag, tokens, value, _len, _ref, _ref2, _ref3;
+      var expr, heredoc, i, inner, interpolated, len, letter, nested, pi, regex, tag, tokens, value, _len, _ref2, _ref3, _ref4;
       if (options == null) {
         options = {};
       }
@@ -503,14 +516,16 @@
             rewrite: false
           });
           nested.pop();
-          if (((_ref = nested[0]) != null ? _ref[0] : void 0) === 'TERMINATOR') {
+          if (((_ref2 = nested[0]) != null ? _ref2[0] : void 0) === 'TERMINATOR') {
             nested.shift();
           }
-          if (nested.length > 1) {
-            nested.unshift(['(', '(']);
-            nested.push([')', ')']);
+          if (len = nested.length) {
+            if (len > 1) {
+              nested.unshift(['(', '(']);
+              nested.push([')', ')']);
+            }
+            tokens.push(['TOKENS', nested]);
           }
-          tokens.push(['TOKENS', nested]);
         }
         i += expr.length;
         pi = i + 1;
@@ -531,12 +546,12 @@
         this.token('(', '(');
       }
       for (i = 0, _len = tokens.length; i < _len; i++) {
-        _ref2 = tokens[i], tag = _ref2[0], value = _ref2[1];
+        _ref3 = tokens[i], tag = _ref3[0], value = _ref3[1];
         if (i) {
           this.token('+', '+');
         }
         if (tag === 'TOKENS') {
-          (_ref3 = this.tokens).push.apply(_ref3, value);
+          (_ref4 = this.tokens).push.apply(_ref4, value);
         } else {
           this.token('STRING', this.makeString(value, '"', heredoc));
         }
@@ -582,7 +597,7 @@
   })();
   JS_KEYWORDS = ['true', 'false', 'null', 'this', 'new', 'delete', 'typeof', 'in', 'instanceof', 'return', 'throw', 'break', 'continue', 'debugger', 'if', 'else', 'switch', 'for', 'while', 'do', 'try', 'catch', 'finally', 'class', 'extends', 'super'];
   COFFEE_KEYWORDS = ['undefined', 'then', 'unless', 'until', 'loop', 'of', 'by', 'when'];
-  for (op in COFFEE_ALIASES = {
+  COFFEE_ALIAS_MAP = {
     and: '&&',
     or: '||',
     is: '==',
@@ -592,14 +607,21 @@
     no: 'false',
     on: 'true',
     off: 'false'
-  }) {
-    COFFEE_KEYWORDS.push(op);
-  }
+  };
+  COFFEE_ALIASES = (function() {
+    var _results;
+    _results = [];
+    for (key in COFFEE_ALIAS_MAP) {
+      _results.push(key);
+    }
+    return _results;
+  })();
+  COFFEE_KEYWORDS = COFFEE_KEYWORDS.concat(COFFEE_ALIASES);
   RESERVED = ['case', 'default', 'function', 'var', 'void', 'with', 'const', 'let', 'enum', 'export', 'import', 'native', '__hasProp', '__extends', '__slice', '__bind', '__indexOf'];
   JS_FORBIDDEN = JS_KEYWORDS.concat(RESERVED);
   exports.RESERVED = RESERVED.concat(JS_KEYWORDS).concat(COFFEE_KEYWORDS);
-  IDENTIFIER = /^([$A-Za-z_][$\w]*)([^\n\S]*:(?!:))?/;
-  NUMBER = /^0x[\da-f]+|^(?:\d+(\.\d+)?|\.\d+)(?:e[+-]?\d+)?/i;
+  IDENTIFIER = /^([$A-Za-z_\x7f-\uffff][$\w\x7f-\uffff]*)([^\n\S]*:(?!:))?/;
+  NUMBER = /^0x[\da-f]+|^\d*\.?\d+(?:e[+-]?\d+)?/i;
   HEREDOC = /^("""|''')([\s\S]*?)(?:\n[^\n\S]*)?\1/;
   OPERATOR = /^(?:[-=]>|[-+*\/%<>&|^!?=]=|>>>=?|([-+:])\1|([&|<>])\2=?|\?\.|\.{2,3})/;
   WHITESPACE = /^[^\n\S]+/;
@@ -608,13 +630,14 @@
   MULTI_DENT = /^(?:\n[^\n\S]*)+/;
   SIMPLESTR = /^'[^\\']*(?:\\.[^\\']*)*'/;
   JSTOKEN = /^`[^\\`]*(?:\\.[^\\`]*)*`/;
-  REGEX = /^\/(?!\s)[^[\/\n\\]*(?:(?:\\[\s\S]|\[[^\]\n\\]*(?:\\[\s\S][^\]\n\\]*)*])[^[\/\n\\]*)*\/[imgy]{0,4}(?!\w)/;
+  REGEX = /^\/(?![\s=])[^[\/\n\\]*(?:(?:\\[\s\S]|\[[^\]\n\\]*(?:\\[\s\S][^\]\n\\]*)*])[^[\/\n\\]*)*\/[imgy]{0,4}(?!\w)/;
   HEREGEX = /^\/{3}([\s\S]+?)\/{3}([imgy]{0,4})(?!\w)/;
   HEREGEX_OMIT = /\s+(?:#.*)?/g;
   MULTILINER = /\n/g;
   HEREDOC_INDENT = /\n+([^\n\S]*)/g;
-  ASSIGNED = /^\s*@?([$A-Za-z_][$\w]*|['"].*['"])[^\n\S]*?[:=][^:=>]/;
-  LINE_CONTINUER = /^\s*(?:,|\??\.(?!\.)|::)/;
+  HEREDOC_ILLEGAL = /\*\//;
+  ASSIGNED = /^\s*@?([$A-Za-z_][$\w\x7f-\uffff]*|['"].*['"])[^\n\S]*?[:=][^:=>]/;
+  LINE_CONTINUER = /^\s*(?:,|\??\.(?![.\d])|::)/;
   TRAILING_SPACES = /\s+$/;
   NO_NEWLINE = /^(?:[-+*&|\/%=<>!.\\][<>=&|]*|and|or|is(?:nt)?|n(?:ot|ew)|delete|typeof|instanceof)$/;
   COMPOUND_ASSIGN = ['-=', '+=', '/=', '*=', '%=', '||=', '&&=', '?=', '<<=', '>>=', '>>>=', '&=', '^=', '|='];

lib/optparse.js

@@ -42,7 +42,7 @@
     };
     OptionParser.prototype.help = function() {
       var letPart, lines, rule, spaces, _i, _len, _ref;
-      lines = ['Available options:'];
+      lines = [];
       if (this.banner) {
         lines.unshift("" + this.banner + "\n");
       }

lib/repl.js

@@ -1,42 +1,123 @@
 (function() {
-  var CoffeeScript, error, helpers, readline, repl, run, stdio;
+  var ACCESSOR, CoffeeScript, Module, REPL_PROMPT, REPL_PROMPT_CONTINUATION, SIMPLEVAR, Script, autocomplete, backlog, completeAttribute, completeVariable, enableColours, error, g, getCompletions, inspect, nonContextGlobals, readline, repl, run, sandbox, stdin, stdout, _i, _len;
   CoffeeScript = require('./coffee-script');
-  helpers = require('./helpers');
   readline = require('readline');
-  stdio = process.openStdin();
+  inspect = require('util').inspect;
+  Script = require('vm').Script;
+  Module = require('module');
+  REPL_PROMPT = 'coffee> ';
+  REPL_PROMPT_CONTINUATION = '......> ';
+  enableColours = false;
+  if (process.platform !== 'win32') {
+    enableColours = !process.env.NODE_DISABLE_COLORS;
+  }
+  stdin = process.openStdin();
+  stdout = process.stdout;
   error = function(err) {
-    return stdio.write((err.stack || err.toString()) + '\n\n');
+    return stdout.write((err.stack || err.toString()) + '\n\n');
   };
-  helpers.extend(global, {
-    quit: function() {
-      return process.exit(0);
-    }
-  });
+  backlog = '';
+  sandbox = Script.createContext();
+  nonContextGlobals = ['Buffer', 'console', 'process', 'setInterval', 'clearInterval', 'setTimeout', 'clearTimeout'];
+  for (_i = 0, _len = nonContextGlobals.length; _i < _len; _i++) {
+    g = nonContextGlobals[_i];
+    sandbox[g] = global[g];
+  }
+  sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox;
   run = function(buffer) {
-    var val;
+    var code, returnValue, _;
+    if (!buffer.toString().trim() && !backlog) {
+      repl.prompt();
+      return;
+    }
+    code = backlog += buffer;
+    if (code[code.length - 1] === '\\') {
+      backlog = "" + backlog.slice(0, -1) + "\n";
+      repl.setPrompt(REPL_PROMPT_CONTINUATION);
+      repl.prompt();
+      return;
+    }
+    repl.setPrompt(REPL_PROMPT);
+    backlog = '';
     try {
-      val = CoffeeScript.eval(buffer.toString(), {
-        bare: true,
-        globals: true,
-        fileName: 'repl'
+      _ = sandbox._;
+      returnValue = CoffeeScript.eval("_=(" + code + "\n)", {
+        sandbox: sandbox,
+        filename: 'repl',
+        modulename: 'repl'
       });
-      if (val !== void 0) {
-        console.log(val);
+      if (returnValue === void 0) {
+        sandbox._ = _;
+      } else {
+        process.stdout.write(inspect(returnValue, false, 2, enableColours) + '\n');
       }
     } catch (err) {
       error(err);
     }
     return repl.prompt();
   };
+  ACCESSOR = /\s*([\w\.]+)(?:\.(\w*))$/;
+  SIMPLEVAR = /\s*(\w*)$/i;
+  autocomplete = function(text) {
+    return completeAttribute(text) || completeVariable(text) || [[], text];
+  };
+  completeAttribute = function(text) {
+    var all, completions, match, obj, prefix, val;
+    if (match = text.match(ACCESSOR)) {
+      all = match[0], obj = match[1], prefix = match[2];
+      try {
+        val = Script.runInContext(obj, sandbox);
+      } catch (error) {
+        return;
+      }
+      completions = getCompletions(prefix, Object.getOwnPropertyNames(val));
+      return [completions, prefix];
+    }
+  };
+  completeVariable = function(text) {
+    var completions, free, possibilities, vars, _ref;
+    if (free = (_ref = text.match(SIMPLEVAR)) != null ? _ref[1] : void 0) {
+      vars = Script.runInContext('Object.getOwnPropertyNames(this)', sandbox);
+      possibilities = vars.concat(CoffeeScript.RESERVED);
+      completions = getCompletions(free, possibilities);
+      return [completions, free];
+    }
+  };
+  getCompletions = function(prefix, candidates) {
+    var el, _j, _len2, _results;
+    _results = [];
+    for (_j = 0, _len2 = candidates.length; _j < _len2; _j++) {
+      el = candidates[_j];
+      if (el.indexOf(prefix) === 0) {
+        _results.push(el);
+      }
+    }
+    return _results;
+  };
   process.on('uncaughtException', error);
-  repl = readline.createInterface(stdio);
-  repl.setPrompt('coffee> ');
-  stdio.on('data', function(buffer) {
-    return repl.write(buffer);
+  if (readline.createInterface.length < 3) {
+    repl = readline.createInterface(stdin, autocomplete);
+    stdin.on('data', function(buffer) {
+      return repl.write(buffer);
+    });
+  } else {
+    repl = readline.createInterface(stdin, stdout, autocomplete);
+  }
+  repl.on('attemptClose', function() {
+    if (backlog) {
+      backlog = '';
+      process.stdout.write('\n');
+      repl.setPrompt(REPL_PROMPT);
+      return repl.prompt();
+    } else {
+      return repl.close();
+    }
   });
   repl.on('close', function() {
-    return stdio.destroy();
+    process.stdout.write('\n');
+    return stdin.destroy();
   });
   repl.on('line', run);
+  repl.setPrompt(REPL_PROMPT);
   repl.prompt();
 }).call(this);

lib/rewriter.js

@@ -121,7 +121,10 @@
         return ((tag === 'TERMINATOR' || tag === 'OUTDENT') && !((two != null ? two[0] : void 0) === ':' || (one != null ? one[0] : void 0) === '@' && (three != null ? three[0] : void 0) === ':')) || (tag === ',' && one && ((_ref2 = one[0]) !== 'IDENTIFIER' && _ref2 !== 'NUMBER' && _ref2 !== 'STRING' && _ref2 !== '@' && _ref2 !== 'TERMINATOR' && _ref2 !== 'OUTDENT'));
       };
       action = function(token, i) {
-        return this.tokens.splice(i, 0, ['}', '}', token[2]]);
+        var tok;
+        tok = ['}', '}', token[2]];
+        tok.generated = true;
+        return this.tokens.splice(i, 0, tok);
       };
       return this.scanTokens(function(token, i, tokens) {
         var ago, idx, tag, tok, value, _ref, _ref2;
@@ -159,7 +162,7 @@
         return this.tokens.splice(idx, 0, ['CALL_END', ')', token[2]]);
       };
       return this.scanTokens(function(token, i, tokens) {
-        var callObject, current, next, prev, seenSingle, tag, _ref, _ref2, _ref3;
+        var callObject, current, next, prev, seenControl, seenSingle, tag, _ref, _ref2, _ref3;
         tag = token[0];
         if (tag === 'CLASS' || tag === 'IF') {
           noCall = true;
@@ -167,29 +170,36 @@
         _ref = tokens.slice(i - 1, (i + 1 + 1) || 9e9), prev = _ref[0], current = _ref[1], next = _ref[2];
         callObject = !noCall && tag === 'INDENT' && next && next.generated && next[0] === '{' && prev && (_ref2 = prev[0], __indexOf.call(IMPLICIT_FUNC, _ref2) >= 0);
         seenSingle = false;
+        seenControl = false;
         if (__indexOf.call(LINEBREAKS, tag) >= 0) {
           noCall = false;
         }
         if (prev && !prev.spaced && tag === '?') {
           token.call = true;
         }
+        if (token.fromThen) {
+          return 1;
+        }
         if (!(callObject || (prev != null ? prev.spaced : void 0) && (prev.call || (_ref3 = prev[0], __indexOf.call(IMPLICIT_FUNC, _ref3) >= 0)) && (__indexOf.call(IMPLICIT_CALL, tag) >= 0 || !(token.spaced || token.newLine) && __indexOf.call(IMPLICIT_UNSPACED_CALL, tag) >= 0))) {
           return 1;
         }
         tokens.splice(i, 0, ['CALL_START', '(', token[2]]);
         this.detectEnd(i + 1, function(token, i) {
-          var post, _ref;
+          var post, _ref4;
           tag = token[0];
           if (!seenSingle && token.fromThen) {
             return true;
           }
-          if (tag === 'IF' || tag === 'ELSE' || tag === '->' || tag === '=>') {
+          if (tag === 'IF' || tag === 'ELSE' || tag === 'CATCH' || tag === '->' || tag === '=>') {
             seenSingle = true;
           }
+          if (tag === 'IF' || tag === 'ELSE' || tag === 'SWITCH' || tag === 'TRY') {
+            seenControl = true;
+          }
           if ((tag === '.' || tag === '?.' || tag === '::') && this.tag(i - 1) === 'OUTDENT') {
             return true;
           }
-          return !token.generated && this.tag(i - 1) !== ',' && __indexOf.call(IMPLICIT_END, tag) >= 0 && (tag !== 'INDENT' || (this.tag(i - 2) !== 'CLASS' && (_ref = this.tag(i - 1), __indexOf.call(IMPLICIT_BLOCK, _ref) < 0) && !((post = this.tokens[i + 1]) && post.generated && post[0] === '{')));
+          return !token.generated && this.tag(i - 1) !== ',' && (__indexOf.call(IMPLICIT_END, tag) >= 0 || (tag === 'INDENT' && !seenControl)) && (tag !== 'INDENT' || (this.tag(i - 2) !== 'CLASS' && (_ref4 = this.tag(i - 1), __indexOf.call(IMPLICIT_BLOCK, _ref4) < 0) && !((post = this.tokens[i + 1]) && post.generated && post[0] === '{')));
         }, action);
         if (prev[0] === '?') {
           prev[0] = 'FUNC_EXIST';
@@ -222,8 +232,8 @@
           indent.generated = outdent.generated = true;
           tokens.splice(i + 1, 0, indent);
           condition = function(token, i) {
-            var _ref;
-            return token[1] !== ';' && (_ref = token[0], __indexOf.call(SINGLE_CLOSERS, _ref) >= 0) && !(token[0] === 'ELSE' && (starter !== 'IF' && starter !== 'THEN'));
+            var _ref3;
+            return token[1] !== ';' && (_ref3 = token[0], __indexOf.call(SINGLE_CLOSERS, _ref3) >= 0) && !(token[0] === 'ELSE' && (starter !== 'IF' && starter !== 'THEN'));
           };
           action = function(token, i) {
             return this.tokens.splice((this.tag(i - 1) === ',' ? i - 1 : i), 0, outdent);
@@ -346,7 +356,7 @@
   IMPLICIT_CALL = ['IDENTIFIER', 'NUMBER', 'STRING', 'JS', 'REGEX', 'NEW', 'PARAM_START', 'CLASS', 'IF', 'TRY', 'SWITCH', 'THIS', 'BOOL', 'UNARY', 'SUPER', '@', '->', '=>', '[', '(', '{', '--', '++'];
   IMPLICIT_UNSPACED_CALL = ['+', '-'];
   IMPLICIT_BLOCK = ['->', '=>', '{', '[', ','];
-  IMPLICIT_END = ['POST_IF', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR', 'INDENT'];
+  IMPLICIT_END = ['POST_IF', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR'];
   SINGLE_LINERS = ['ELSE', '->', '=>', 'TRY', 'FINALLY', 'THEN'];
   SINGLE_CLOSERS = ['TERMINATOR', 'CATCH', 'FINALLY', 'ELSE', 'OUTDENT', 'LEADING_WHEN'];
   LINEBREAKS = ['TERMINATOR', 'INDENT', 'OUTDENT'];

lib/scope.js

@@ -46,12 +46,12 @@
       return this.add(name, 'param');
     };
     Scope.prototype.check = function(name, immediate) {
-      var found, _ref;
+      var found, _ref2;
       found = !!this.type(name);
       if (found || immediate) {
         return found;
       }
-      return !!((_ref = this.parent) != null ? _ref.check(name) : void 0);
+      return !!((_ref2 = this.parent) != null ? _ref2.check(name) : void 0);
     };
     Scope.prototype.temporary = function(name, index) {
       if (name.length > 1) {
@@ -61,10 +61,10 @@
       }
     };
     Scope.prototype.type = function(name) {
-      var v, _i, _len, _ref;
-      _ref = this.variables;
-      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-        v = _ref[_i];
+      var v, _i, _len, _ref2;
+      _ref2 = this.variables;
+      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+        v = _ref2[_i];
         if (v.name === name) {
           return v.type;
         }
@@ -74,7 +74,7 @@
     Scope.prototype.freeVariable = function(type) {
       var index, temp;
       index = 0;
-      while (this.check((temp = this.temporary(type, index)), true)) {
+      while (this.check((temp = this.temporary(type, index)))) {
         index++;
       }
       this.add(temp, 'var', true);
@@ -91,12 +91,12 @@
       return !!this.declaredVariables().length;
     };
     Scope.prototype.declaredVariables = function() {
-      var realVars, tempVars, v, _i, _len, _ref;
+      var realVars, tempVars, v, _i, _len, _ref2;
       realVars = [];
       tempVars = [];
-      _ref = this.variables;
-      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-        v = _ref[_i];
+      _ref2 = this.variables;
+      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+        v = _ref2[_i];
         if (v.type === 'var') {
           (v.name.charAt(0) === '_' ? tempVars : realVars).push(v.name);
         }
@@ -104,11 +104,11 @@
       return realVars.sort().concat(tempVars.sort());
     };
     Scope.prototype.assignedVariables = function() {
-      var v, _i, _len, _ref, _results;
-      _ref = this.variables;
+      var v, _i, _len, _ref2, _results;
+      _ref2 = this.variables;
       _results = [];
-      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
-        v = _ref[_i];
+      for (_i = 0, _len = _ref2.length; _i < _len; _i++) {
+        v = _ref2[_i];
         if (v.type.assigned) {
           _results.push("" + v.name + " = " + v.type.value);
         }

package.json

@@ -1,22 +1,27 @@
 {
-    "name":         "coffee-script",
-    "description":  "Unfancy JavaScript",
-    "keywords":     ["javascript", "language", "coffeescript", "compiler"],
-    "author":       "Jeremy Ashkenas",
-    "version":      "1.0.0",
-    "licenses":     [{
-      "type":       "MIT",
-      "url":        "http://github.com/jashkenas/coffee-script/raw/master/LICENSE"
-    }],
-    "engines":      {
-      "node":       ">=0.2.5"
-    },
-    "directories" : {
-      "lib" : "./lib"
-    },
-    "main" : "./lib/coffee-script",
-    "bin":          {
-      "coffee":     "./bin/coffee",
-      "cake":       "./bin/cake"
-    }
+  "name":         "coffee-script",
+  "description":  "Unfancy JavaScript",
+  "keywords":     ["javascript", "language", "coffeescript", "compiler"],
+  "author":       "Jeremy Ashkenas",
+  "version":      "1.1.2",
+  "licenses":     [{
+    "type":       "MIT",
+    "url":        "http://github.com/jashkenas/coffee-script/raw/master/LICENSE"
+  }],
+  "engines":      {
+    "node":       ">=0.2.5"
+  },
+  "directories" : {
+    "lib" : "./lib"
+  },
+  "main" : "./lib/coffee-script",
+  "bin":          {
+    "coffee":     "./bin/coffee",
+    "cake":       "./bin/cake"
+  },
+  "homepage":     "http://coffeescript.org",
+  "repository":   {
+    "type": "git",
+    "url": "git://github.com/jashkenas/coffee-script.git"
+  }
 }

src/browser.coffee

@@ -16,24 +16,35 @@ CoffeeScript.run = (code, options = {}) ->
 return unless window?
 
 # Load a remote script from the current domain via XHR.
-CoffeeScript.load = (url, options) ->
+CoffeeScript.load = (url, callback) ->
   xhr = new (window.ActiveXObject or XMLHttpRequest)('Microsoft.XMLHTTP')
   xhr.open 'GET', url, true
   xhr.overrideMimeType 'text/plain' if 'overrideMimeType' of xhr
   xhr.onreadystatechange = ->
-    CoffeeScript.run xhr.responseText, options if xhr.readyState is 4
+    if xhr.readyState is 4
+      if xhr.status in [0, 200]
+        CoffeeScript.run xhr.responseText
+      else
+        throw new Error "Could not load #{url}"
+      callback() if callback
   xhr.send null
 
 # Activate CoffeeScript in the browser by having it compile and evaluate
 # all script tags with a content-type of `text/coffeescript`.
 # This happens on page load.
 runScripts = ->
-  for script in document.getElementsByTagName 'script'
-    if script.type is 'text/coffeescript'
+  scripts = document.getElementsByTagName 'script'
+  coffees = (s for s in scripts when s.type is 'text/coffeescript')
+  index = 0
+  length = coffees.length
+  do execute = ->
+    script = coffees[index++]
+    if script?.type is 'text/coffeescript'
       if script.src
-        CoffeeScript.load script.src
+        CoffeeScript.load script.src, execute
       else
         CoffeeScript.run script.innerHTML
+        execute()
   null
 
 # Listen for window load, both in browsers and in IE.

src/cake.coffee

@@ -47,7 +47,7 @@ exports.run = ->
   path.exists 'Cakefile', (exists) ->
     throw new Error("Cakefile not found in #{process.cwd()}") unless exists
     args = process.argv.slice 2
-    CoffeeScript.run fs.readFileSync('Cakefile').toString(), fileName: 'Cakefile'
+    CoffeeScript.run fs.readFileSync('Cakefile').toString(), filename: 'Cakefile'
     oparse = new optparse.OptionParser switches
     return printTasks() unless args.length
     options = oparse.parse(args)
@@ -63,7 +63,7 @@ printTasks = ->
     console.log "cake #{name}#{spaces} #{desc}"
   console.log oparse.help() if switches.length
 
-# Print an error and exit when attempting to all an undefined task.
+# Print an error and exit when attempting to call an undefined task.
 missingTask = (task) ->
   console.log "No such task: \"#{task}\""
   process.exit 1

src/coffee-script.coffee

@@ -14,13 +14,13 @@ path             = require 'path'
 # TODO: Remove registerExtension when fully deprecated.
 if require.extensions
   require.extensions['.coffee'] = (module, filename) ->
-    content = compile fs.readFileSync filename, 'utf8'
+    content = compile fs.readFileSync(filename, 'utf8'), {filename}
     module._compile content, filename
 else if require.registerExtension
   require.registerExtension '.coffee', (content) -> compile content
 
 # The current CoffeeScript version number.
-exports.VERSION = '1.0.0'
+exports.VERSION = '1.1.2'
 
 # Words that cannot be used as identifiers in CoffeeScript code
 exports.RESERVED = RESERVED
@@ -34,7 +34,7 @@ exports.compile = compile = (code, options = {}) ->
   try
     (parser.parse lexer.tokenize code).compile options
   catch err
-    err.message = "In #{options.fileName}, #{err.message}" if options.fileName
+    err.message = "In #{options.filename}, #{err.message}" if options.filename
     throw err
 
 # Tokenize a string of CoffeeScript code, and return the array of tokens.
@@ -53,26 +53,58 @@ exports.nodes = (source, options) ->
 # Compile and execute a string of CoffeeScript (on the server), correctly
 # setting `__filename`, `__dirname`, and relative `require()`.
 exports.run = (code, options) ->
-  # We want the root module.
-  root = module
-  while root.parent
-    root = root.parent
+  mainModule = require.main
+
   # Set the filename.
-  root.filename = fs.realpathSync options.fileName or '.'
+  mainModule.filename = process.argv[1] =
+      if options.filename then fs.realpathSync(options.filename) else '.'
+
   # Clear the module cache.
-  root.moduleCache = {} if root.moduleCache
+  mainModule.moduleCache and= {}
+
+  # Assign paths for node_modules loading
+  if process.binding('natives').module
+    {Module} = require 'module'
+    mainModule.paths = Module._nodeModulePaths path.dirname options.filename
+
   # Compile.
-  if path.extname(root.filename) isnt '.coffee' or require.extensions
-    root._compile compile(code, options), root.filename
+  if path.extname(mainModule.filename) isnt '.coffee' or require.extensions
+    mainModule._compile compile(code, options), mainModule.filename
   else
-    root._compile code, root.filename
+    mainModule._compile code, mainModule.filename
 
 # Compile and evaluate a string of CoffeeScript (in a Node.js-like environment).
 # The CoffeeScript REPL uses this to run the input.
-exports.eval = (code, options) ->
-  __filename = options.fileName
-  __dirname  = path.dirname __filename
-  eval compile code, options
+exports.eval = (code, options = {}) ->
+  return unless code = code.trim()
+  if {Script} = require 'vm'
+    sandbox = Script.createContext()
+    sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox
+    if options.sandbox?
+      if options.sandbox instanceof sandbox.constructor
+        sandbox = options.sandbox
+      else
+        sandbox[k] = v for own k, v of options.sandbox
+    sandbox.__filename = options.filename || 'eval'
+    sandbox.__dirname  = path.dirname sandbox.__filename
+    # define module/require only if they chose not to specify their own
+    unless sandbox.module or sandbox.require
+      Module = require 'module'
+      sandbox.module  = _module  = new Module(options.modulename || 'eval')
+      sandbox.require = _require = (path) -> Module._load path, _module
+      _module.filename = sandbox.__filename
+      _require[r] = require[r] for r in Object.getOwnPropertyNames require
+      # use the same hack node currently uses for their own REPL
+      _require.paths = _module.paths = Module._nodeModulePaths process.cwd()
+      _require.resolve = (request) -> Module._resolveFilename request, _module
+  o = {}
+  o[k] = v for own k, v of options
+  o.bare = on # ensure return value
+  js = compile code, o
+  if Script
+    Script.runInContext js, sandbox
+  else
+    eval js
 
 # Instantiate a Lexer for our use here.
 lexer = new Lexer

src/command.coffee

@@ -1,13 +1,12 @@
 # The `coffee` utility. Handles command-line compilation of CoffeeScript
 # into various forms: saved into `.js` files or printed to stdout, piped to
-# [JSLint](http://javascriptlint.com/) or recompiled every time the source is
+# [JavaScript Lint](http://javascriptlint.com/) or recompiled every time the source is
 # saved, printed as a token stream or as the syntax tree, or launch an
 # interactive REPL.
 
 # External dependencies.
 fs             = require 'fs'
 path           = require 'path'
-util           = require 'util'
 helpers        = require './helpers'
 optparse       = require './optparse'
 CoffeeScript   = require './coffee-script'
@@ -30,10 +29,10 @@ SWITCHES = [
   ['-c', '--compile',         'compile to JavaScript and save as .js files']
   ['-i', '--interactive',     'run an interactive CoffeeScript REPL']
   ['-o', '--output [DIR]',    'set the directory for compiled JavaScript']
-  ['-j', '--join',            'concatenate the scripts before compiling']
+  ['-j', '--join [FILE]',     'concatenate the scripts before compiling']
   ['-w', '--watch',           'watch scripts for changes, and recompile']
   ['-p', '--print',           'print the compiled JavaScript to stdout']
-  ['-l', '--lint',            'pipe the compiled JavaScript through JSLint']
+  ['-l', '--lint',            'pipe the compiled JavaScript through JavaScript Lint']
   ['-s', '--stdio',           'listen for and compile scripts over stdio']
   ['-e', '--eval',            'compile a string from the command line']
   ['-r', '--require [FILE*]', 'require a library before executing your script']
@@ -59,6 +58,7 @@ exports.run = ->
   return forkNode()                      if opts.nodejs
   return usage()                         if opts.help
   return version()                       if opts.version
+  loadRequires()                         if opts.require
   return require './repl'                if opts.interactive
   return compileStdio()                  if opts.stdio
   return compileScript null, sources[0]  if opts.eval
@@ -66,31 +66,52 @@ exports.run = ->
   if opts.run
     opts.literals = sources.splice(1).concat opts.literals
   process.ARGV = process.argv = process.argv.slice(0, 2).concat opts.literals
+  process.argv[0] = 'coffee'
+  process.execPath = require.main.filename
   compileScripts()
 
 # Asynchronously read in each CoffeeScript in a list of source files and
 # compile them. If a directory is passed, recursively compile all
 # '.coffee' extension source files in it and all subdirectories.
 compileScripts = ->
+  unprocessed = []
+  for source in sources
+    unprocessed[sources.indexOf(source)]=1
   for source in sources
     base = path.join(source)
-    compile = (source, topLevel) ->
+    compile = (source, sourceIndex, topLevel) ->
+      remaining_files = ->
+        total = 0
+        total += x for x in unprocessed
+        total
       path.exists source, (exists) ->
-        throw new Error "File not found: #{source}" unless exists
+        if topLevel and not exists and source[-7..] isnt '.coffee'
+            return compile "#{source}.coffee", sourceIndex, topLevel
+                
+        throw new Error "File not found: #{source}" if topLevel and not exists
         fs.stat source, (err, stats) ->
+          throw err if err
           if stats.isDirectory()
             fs.readdir source, (err, files) ->
+              throw err if err
+              unprocessed[sourceIndex] += files.length
               for file in files
-                compile path.join(source, file)
+                compile path.join(source, file), sourceIndex
+              unprocessed[sourceIndex] -= 1
           else if topLevel or path.extname(source) is '.coffee'
             fs.readFile source, (err, code) ->
+              throw err if err
+              unprocessed[sourceIndex] -= 1
               if opts.join
-                contents[sources.indexOf source] = code.toString()
-                compileJoin() if helpers.compact(contents).length is sources.length
+                contents[sourceIndex] = helpers.compact([contents[sourceIndex], code.toString()]).join('\n')
+                if helpers.compact(contents).length > 0 and remaining_files() == 0
+                  compileJoin()
               else
                 compileScript(source, code.toString(), base)
             watch source, base if opts.watch and not opts.join
-    compile source, true
+          else
+            unprocessed[sourceIndex] -= 1
+    compile source, sources.indexOf(source), true
 
 # Compile a single source script, containing the given code, according to the
 # requested options. If evaluating the script directly sets `__filename`,
@@ -98,8 +119,6 @@ compileScripts = ->
 compileScript = (file, input, base) ->
   o = opts
   options = compileOptions file
-  if o.require
-    require(if helpers.starts(req, '.') then fs.realpathSync(req) else req) for req in o.require
   try
     t = task = {file, input, options}
     CoffeeScript.emit 'compile', task
@@ -133,7 +152,14 @@ compileStdio = ->
 # them together.
 compileJoin = ->
   code = contents.join '\n'
-  compileScript "concatenation", code, "concatenation"
+  compileScript opts.join, code, opts.join
+
+# Load files that are to-be-required before compilation occurs.
+loadRequires = ->
+  realFilename = module.filename
+  module.filename = '.'
+  require req for req in opts.require
+  module.filename = realFilename
 
 # Watch a source CoffeeScript file using `fs.watchFile`, recompiling it every
 # time the file is updated. May be used in combination with other options,
@@ -157,8 +183,10 @@ writeJs = (source, js, base) ->
   compile   = ->
     js = ' ' if js.length <= 0
     fs.writeFile jsPath, js, (err) ->
-      if err then printLine err.message
-      else if opts.compile and opts.watch then util.log "compiled #{source}"
+      if err
+        printLine err.message
+      else if opts.compile and opts.watch
+        console.log "#{(new Date).toLocaleTimeString()} - compiled #{source}"
   path.exists dir, (exists) ->
     if exists then compile() else exec "mkdir -p #{dir}", compile
 
@@ -191,7 +219,7 @@ parseOptions = ->
   sources       = o.arguments
 
 # The compile-time options to pass to the CoffeeScript compiler.
-compileOptions = (fileName) -> {fileName, bare: opts.bare}
+compileOptions = (filename) -> {filename, bare: opts.bare}
 
 # Start up a new Node.js instance with the arguments in `--nodejs` passed to
 # the `node` binary, preserving the other options.
@@ -208,9 +236,7 @@ forkNode = ->
 # shown.
 usage = ->
   printLine (new optparse.OptionParser SWITCHES, BANNER).help()
-  process.exit 0
 
 # Print the `--version` message and exit.
 version = ->
   printLine "CoffeeScript version #{CoffeeScript.VERSION}"
-  process.exit 0

src/grammar.coffee

@@ -35,7 +35,7 @@ o = (patternString, action, options) ->
   return [patternString, '$$ = $1;', options] unless action
   action = if match = unwrap.exec action then match[1] else "(#{action}())"
   action = action.replace /\bnew /g, '$&yy.'
-  action = action.replace /\b(?:Expressions\.wrap|extend)\b/g, 'yy.$&'
+  action = action.replace /\b(?:Block\.wrap|extend)\b/g, 'yy.$&'
   [patternString, "$$ = #{action};", options]
 
 # Grammatical Rules
@@ -56,19 +56,19 @@ grammar =
   # The **Root** is the top-level node in the syntax tree. Since we parse bottom-up,
   # all parsing must end here.
   Root: [
-    o '',                                       -> new Expressions
+    o '',                                       -> new Block
     o 'Body'
     o 'Block TERMINATOR'
   ]
 
   # Any list of statements and expressions, separated by line breaks or semicolons.
   Body: [
-    o 'Line',                                   -> Expressions.wrap [$1]
+    o 'Line',                                   -> Block.wrap [$1]
     o 'Body TERMINATOR Line',                   -> $1.push $3
     o 'Body TERMINATOR'
   ]
 
-  # Expressions and statements, which make up a line in a body.
+  # Block and statements, which make up a line in a body.
   Line: [
     o 'Expression'
     o 'Statement'
@@ -84,7 +84,7 @@ grammar =
 
   # All the different types of expressions in our language. The basic unit of
   # CoffeeScript is the **Expression** -- everything that can be an expression
-  # is one. Expressions serve as the building blocks of many other rules, making
+  # is one. Blocks serve as the building blocks of many other rules, making
   # them somewhat circular.
   Expression: [
     o 'Value'
@@ -104,7 +104,7 @@ grammar =
   # will convert some postfix forms into blocks for us, by adjusting the
   # token stream.
   Block: [
-    o 'INDENT OUTDENT',                         -> new Expressions
+    o 'INDENT OUTDENT',                         -> new Block
     o 'INDENT Body OUTDENT',                    -> $2
   ]
 
@@ -120,14 +120,16 @@ grammar =
     o 'STRING',                                 -> new Literal $1
   ]
 
-  # All of our immediate values. These can (in general), be passed straight
+  # All of our immediate values. Generally these can be passed straight
   # through and printed to JavaScript.
   Literal: [
     o 'AlphaNumeric'
     o 'JS',                                     -> new Literal $1
     o 'REGEX',                                  -> new Literal $1
     o 'BOOL',                                   ->
-      new Literal if $1 is 'undefined' then 'void 0' else $1
+      val = new Literal $1
+      val.isUndefined = yes if $1 is 'undefined'
+      val
   ]
 
   # Assignment of a variable, property, or index to a value.
@@ -164,7 +166,7 @@ grammar =
   ]
 
   # The **Code** node is the function literal. It's defined by an indented block
-  # of **Expressions** preceded by a function arrow, with an optional parameter
+  # of **Block** preceded by a function arrow, with an optional parameter
   # list.
   Code: [
     o 'PARAM_START ParamList PARAM_END FuncGlyph Block', -> new Code $2, $5, $4
@@ -199,6 +201,7 @@ grammar =
     o 'ParamVar = Expression',                  -> new Param $1, $3
   ]
 
+ # Function Parameters
   ParamVar: [
     o 'Identifier'
     o 'ThisProperty'
@@ -244,16 +247,20 @@ grammar =
     o ':: Identifier',                          -> new Access $2, 'proto'
     o '::',                                     -> new Access new Literal 'prototype'
     o 'Index'
-    o 'Slice',                                  -> new Slice $1
   ]
 
   # Indexing into an object or array using bracket notation.
   Index: [
-    o 'INDEX_START Expression INDEX_END',       -> new Index $2
+    o 'INDEX_START IndexValue INDEX_END',       -> $2
     o 'INDEX_SOAK  Index',                      -> extend $2, soak : yes
     o 'INDEX_PROTO Index',                      -> extend $2, proto: yes
   ]
 
+  IndexValue: [
+    o 'Expression',                             -> new Index $1
+    o 'Slice',                                  -> new Slice $1
+  ]
+
   # In CoffeeScript, an object literal is simply a list of assignments.
   Object: [
     o '{ AssignList OptComma }',                -> new Obj $2, $1.generated
@@ -332,9 +339,9 @@ grammar =
 
   # Array slice literals.
   Slice: [
-    o 'INDEX_START Expression RangeDots Expression INDEX_END', -> new Range $2, $4, $3
-    o 'INDEX_START Expression RangeDots INDEX_END', -> new Range $2, null, $3
-    o 'INDEX_START RangeDots Expression INDEX_END', -> new Range null, $3, $2
+    o 'Expression RangeDots Expression',        -> new Range $1, $3, $2
+    o 'Expression RangeDots',                   -> new Range $1, null, $2
+    o 'RangeDots Expression',                   -> new Range null, $2, $1
   ]
 
   # The **ArgList** is both the list of objects passed into a function call,
@@ -348,7 +355,7 @@ grammar =
     o 'ArgList OptComma INDENT ArgList OptComma OUTDENT', -> $1.concat $4
   ]
 
-  # Valid arguments are Expressions or Splats.
+  # Valid arguments are Blocks or Splats.
   Arg: [
     o 'Expression'
     o 'Splat'
@@ -401,14 +408,14 @@ grammar =
   # or postfix, with a single expression. There is no do..while.
   While: [
     o 'WhileSource Block',                      -> $1.addBody $2
-    o 'Statement  WhileSource',                 -> $2.addBody Expressions.wrap [$1]
-    o 'Expression WhileSource',                 -> $2.addBody Expressions.wrap [$1]
+    o 'Statement  WhileSource',                 -> $2.addBody Block.wrap [$1]
+    o 'Expression WhileSource',                 -> $2.addBody Block.wrap [$1]
     o 'Loop',                                   -> $1
   ]
 
   Loop: [
     o 'LOOP Block',                             -> new While(new Literal 'true').addBody $2
-    o 'LOOP Expression',                        -> new While(new Literal 'true').addBody Expressions.wrap [$2]
+    o 'LOOP Expression',                        -> new While(new Literal 'true').addBody Block.wrap [$2]
   ]
 
   # Array, object, and range comprehensions, at the most generic level.
@@ -483,15 +490,15 @@ grammar =
   IfBlock: [
     o 'IF Expression Block',                    -> new If $2, $3, type: $1
     o 'IfBlock ELSE IF Expression Block',       -> $1.addElse new If $4, $5, type: $3
-    o 'IfBlock ELSE Block',                     -> $1.addElse $3
   ]
 
   # The full complement of *if* expressions, including postfix one-liner
   # *if* and *unless*.
   If: [
     o 'IfBlock'
-    o 'Statement  POST_IF Expression',          -> new If $3, Expressions.wrap([$1]), type: $2, statement: true
-    o 'Expression POST_IF Expression',          -> new If $3, Expressions.wrap([$1]), type: $2, statement: true
+    o 'IfBlock ELSE Block',                     -> $1.addElse $3
+    o 'Statement  POST_IF Expression',          -> new If $3, Block.wrap([$1]), type: $2, statement: true
+    o 'Expression POST_IF Expression',          -> new If $3, Block.wrap([$1]), type: $2, statement: true
   ]
 
   # Arithmetic and logical operators, working on one or more operands.
@@ -567,7 +574,7 @@ operators = [
 # Wrapping Up
 # -----------
 
-# Finally, now what we have our **grammar** and our **operators**, we can create
+# Finally, now that we have our **grammar** and our **operators**, we can create
 # our **Jison.Parser**. We do this by processing all of our rules, recording all
 # terminals (every symbol which does not appear as the name of a rule above)
 # as "tokens".

src/lexer.coffee

@@ -32,6 +32,7 @@ exports.Lexer = class Lexer
   # Before returning the token stream, run it through the [Rewriter](rewriter.html)
   # unless explicitly asked not to.
   tokenize: (code, opts = {}) ->
+    code     = "\n#{code}" if WHITESPACE.test code
     code     = code.replace(/\r/g, '').replace TRAILING_SPACES, ''
 
     @code    = code           # The remainder of the source code.
@@ -79,11 +80,11 @@ exports.Lexer = class Lexer
       @token 'OWN', id
       return id.length
     forcedIdentifier = colon or
-      (prev = last @tokens) and not prev.spaced and prev[0] in ['.', '?.', '@', '::']
+      (prev = last @tokens) and (prev[0] in ['.', '?.', '::'] or
+      not prev.spaced and prev[0] is '@')
     tag = 'IDENTIFIER'
 
-    if id in JS_KEYWORDS or
-       not forcedIdentifier and id in COFFEE_KEYWORDS
+    if not forcedIdentifier and (id in JS_KEYWORDS or id in COFFEE_KEYWORDS)
       tag = id.toUpperCase()
       if tag is 'WHEN' and @tag() in LINE_BREAK
         tag = 'LEADING_WHEN'
@@ -112,7 +113,7 @@ exports.Lexer = class Lexer
         @identifierError id
 
     unless forcedIdentifier
-      id  = COFFEE_ALIASES[id] if COFFEE_ALIASES.hasOwnProperty id
+      id  = COFFEE_ALIAS_MAP[id] if id in COFFEE_ALIASES
       tag = switch id
         when '!'                                  then 'UNARY'
         when '==', '!='                           then 'COMPARE'
@@ -169,11 +170,11 @@ exports.Lexer = class Lexer
   commentToken: ->
     return 0 unless match = @chunk.match COMMENT
     [comment, here] = match
-    @line += count comment, '\n'
     if here
       @token 'HERECOMMENT', @sanitizeHeredoc here,
         herecomment: true, indent: Array(@indent + 1).join(' ')
       @token 'TERMINATOR', '\n'
+    @line += count comment, '\n'
     comment.length
 
   # Matches JavaScript interpolated directly into the source via backticks.
@@ -187,7 +188,11 @@ exports.Lexer = class Lexer
   # JavaScript and Ruby.
   regexToken: ->
     return 0 if @chunk.charAt(0) isnt '/'
-    return @heregexToken match if match = HEREGEX.exec @chunk
+    if match = HEREGEX.exec @chunk
+      length = @heregexToken match
+      @line += count match[0], '\n'
+      return length
+
     prev = last @tokens
     return 0 if prev and (prev[0] in (if prev.spaced then NOT_REGEX else NOT_SPACED_REGEX))
     return 0 unless match = REGEX.exec @chunk
@@ -342,8 +347,11 @@ exports.Lexer = class Lexer
   # erasing all external indentation on the left-hand side.
   sanitizeHeredoc: (doc, options) ->
     {indent, herecomment} = options
-    return doc if herecomment and 0 > doc.indexOf '\n'
-    unless herecomment
+    if herecomment
+      if HEREDOC_ILLEGAL.test doc
+        throw new Error "block comment cannot contain \"*/\", starting on line #{@line + 1}"
+      return doc if doc.indexOf('\n') <= 0
+    else
       while match = HEREDOC_INDENT.exec doc
         attempt = match[1]
         indent = attempt if indent is null or 0 < attempt.length < indent.length
@@ -366,9 +374,10 @@ exports.Lexer = class Lexer
           stack.push tok
         when '(', 'CALL_START'
           if stack.length then stack.pop()
-          else
+          else if tok[0] is '('
             tok[0] = 'PARAM_START'
             return this
+          else return this
     this
 
   # Close up all remaining open blocks at the end of the file.
@@ -404,6 +413,8 @@ exports.Lexer = class Lexer
           continue
       if end is '}' and letter in ['"', "'"]
         stack.push end = letter
+      else if end is '}' and letter is '/' and match = (HEREGEX.exec(str.slice i) or REGEX.exec(str.slice i))
+        i += match[0].length - 1
       else if end is '}' and letter is '{'
         stack.push end = '}'
       else if end is '"' and prev is '#' and letter is '{'
@@ -438,10 +449,11 @@ exports.Lexer = class Lexer
         nested = new Lexer().tokenize inner, line: @line, rewrite: off
         nested.pop()
         nested.shift() if nested[0]?[0] is 'TERMINATOR'
-        if nested.length > 1
-          nested.unshift ['(', '(']
-          nested.push    [')', ')']
-        tokens.push ['TOKENS', nested]
+        if len = nested.length
+          if len > 1
+            nested.unshift ['(', '(']
+            nested.push    [')', ')']
+          tokens.push ['TOKENS', nested]
       i += expr.length
       pi = i + 1
     tokens.push ['NEOSTRING', str.slice pi] if i > pi < str.length
@@ -506,7 +518,8 @@ JS_KEYWORDS = [
 
 # CoffeeScript-only keywords.
 COFFEE_KEYWORDS = ['undefined', 'then', 'unless', 'until', 'loop', 'of', 'by', 'when']
-COFFEE_KEYWORDS.push op for op of COFFEE_ALIASES =
+
+COFFEE_ALIAS_MAP =
   and  : '&&'
   or   : '||'
   is   : '=='
@@ -517,6 +530,9 @@ COFFEE_KEYWORDS.push op for op of COFFEE_ALIASES =
   on   : 'true'
   off  : 'false'
 
+COFFEE_ALIASES  = (key for key of COFFEE_ALIAS_MAP)
+COFFEE_KEYWORDS = COFFEE_KEYWORDS.concat COFFEE_ALIASES
+
 # The list of keywords that are reserved by JavaScript, but not used, or are
 # used by CoffeeScript internally. We throw an error when these are encountered,
 # to avoid having a JavaScript error at runtime.
@@ -534,13 +550,13 @@ exports.RESERVED = RESERVED.concat(JS_KEYWORDS).concat(COFFEE_KEYWORDS)
 
 # Token matching regexes.
 IDENTIFIER = /// ^
-  ( [$A-Za-z_][$\w]* )
+  ( [$A-Za-z_\x7f-\uffff][$\w\x7f-\uffff]* )
   ( [^\n\S]* : (?!:) )?  # Is this a property name?
 ///
 
 NUMBER     = ///
   ^ 0x[\da-f]+ |                              # hex
-  ^ (?: \d+(\.\d+)? | \.\d+ ) (?:e[+-]?\d+)?  # decimal
+  ^ \d*\.?\d+ (?:e[+-]?\d+)?  # decimal
 ///i
 
 HEREDOC    = /// ^ ("""|''') ([\s\S]*?) (?:\n[^\n\S]*)? \1 ///
@@ -569,7 +585,7 @@ JSTOKEN    = /^`[^\\`]*(?:\\.[^\\`]*)*`/
 
 # Regex-matching-regexes.
 REGEX = /// ^
-  / (?! \s )       # disallow leading whitespace
+  / (?! [\s=] )       # disallow leading whitespace or equals signs
   [^ [ / \n \\ ]*  # every other thing
   (?:
     (?: \\[\s\S]   # anything escaped
@@ -591,9 +607,11 @@ MULTILINER      = /\n/g
 
 HEREDOC_INDENT  = /\n+([^\n\S]*)/g
 
-ASSIGNED        = /^\s*@?([$A-Za-z_][$\w]*|['"].*['"])[^\n\S]*?[:=][^:=>]/
+HEREDOC_ILLEGAL = /\*\//
 
-LINE_CONTINUER  = /// ^ \s* (?: , | \??\.(?!\.) | :: ) ///
+ASSIGNED        = /^\s*@?([$A-Za-z_][$\w\x7f-\uffff]*|['"].*['"])[^\n\S]*?[:=][^:=>]/
+
+LINE_CONTINUER  = /// ^ \s* (?: , | \??\.(?![.\d]) | :: ) ///
 
 TRAILING_SPACES = /\s+$/
 
@@ -641,7 +659,7 @@ NOT_REGEX = ['NUMBER', 'REGEX', 'BOOL', '++', '--', ']']
 # force a division parse:
 NOT_SPACED_REGEX = NOT_REGEX.concat ')', '}', 'THIS', 'IDENTIFIER', 'STRING'
 
-# Tokens which could legitimately be invoked or indexed. A opening
+# Tokens which could legitimately be invoked or indexed. An opening
 # parentheses or bracket following these tokens will be recorded as the start
 # of a function invocation or indexing operation.
 CALLABLE  = ['IDENTIFIER', 'STRING', 'REGEX', ')', ']', '}', '?', '::', '@', 'THIS', 'SUPER']

src/nodes.coffee

@@ -48,7 +48,7 @@ exports.Base = class Base
   # Statements converted into expressions via closure-wrapping share a scope
   # object with their parent closure, to preserve the expected lexical scope.
   compileClosure: (o) ->
-    if @jumps()
+    if @jumps() or this instanceof Throw
       throw SyntaxError 'cannot use a pure statement in an expression.'
     o.sharedScope = yes
     Closure.wrap(this).compileNode o
@@ -145,12 +145,12 @@ exports.Base = class Base
   # Is this node used to assign a certain variable?
   assigns: NO
 
-#### Expressions
+#### Block
 
-# The expressions body is the list of expressions that forms the body of an
+# The block is the list of expressions that forms the body of an
 # indented block of code -- the implementation of a function, a clause in an
 # `if`, `switch`, or `try`, and so on...
-exports.Expressions = class Expressions extends Base
+exports.Block = class Block extends Base
   constructor: (nodes) ->
     @expressions = compact flatten nodes or []
 
@@ -170,7 +170,7 @@ exports.Expressions = class Expressions extends Base
     @expressions.unshift node
     this
 
-  # If this Expressions consists of just a single node, unwrap it by pulling
+  # If this Block consists of just a single node, unwrap it by pulling
   # it back out.
   unwrap: ->
     if @expressions.length is 1 then @expressions[0] else this
@@ -188,7 +188,7 @@ exports.Expressions = class Expressions extends Base
     for exp in @expressions
       return exp if exp.jumps o
 
-  # An Expressions node does not return its entire body, rather it
+  # A Block node does not return its entire body, rather it
   # ensures that the final expression is returned.
   makeReturn: ->
     len = @expressions.length
@@ -196,14 +196,15 @@ exports.Expressions = class Expressions extends Base
       expr = @expressions[len]
       if expr not instanceof Comment
         @expressions[len] = expr.makeReturn()
+        @expressions.splice(len, 1) if expr instanceof Return and not expr.expression
         break
     this
 
-  # An **Expressions** is the only node that can serve as the root.
+  # A **Block** is the only node that can serve as the root.
   compile: (o = {}, level) ->
     if o.scope then super o, level else @compileRoot o
 
-  # Compile all expressions within the **Expressions** body. If we need to
+  # Compile all expressions within the **Block** body. If we need to
   # return the result, and it's an expression, simply return it. If it's a
   # statement, ask the statement to do so.
   compileNode: (o) ->
@@ -213,7 +214,12 @@ exports.Expressions = class Expressions extends Base
     for node in @expressions
       node = node.unwrapAll()
       node = (node.unfoldSoak(o) or node)
-      if top
+      if node instanceof Block
+        # This is a nested block.  We don't do anything special here like enclose
+        # it in a new scope; we just compile the statements in this block along with
+        # our own
+        codes.push node.compileNode o
+      else if top
         node.front = true
         code = node.compile o
         codes.push if node.isStatement o then code else @tab + code + ';'
@@ -223,7 +229,7 @@ exports.Expressions = class Expressions extends Base
     code = codes.join(', ') or 'void 0'
     if codes.length > 1 and o.level >= LEVEL_LIST then "(#{code})" else code
 
-  # If we happen to be the top-level **Expressions**, wrap everything in
+  # If we happen to be the top-level **Block**, wrap everything in
   # a safety closure, unless requested not to.
   # It would be better not to generate them in the first place, but for now,
   # clean up obvious double-parentheses.
@@ -232,7 +238,6 @@ exports.Expressions = class Expressions extends Base
     o.scope  = new Scope null, this, null
     o.level  = LEVEL_TOP
     code     = @compileWithDeclarations o
-    code     = code.replace TRAILING_WHITESPACE, ''
     if o.bare then code else "(function() {\n#{code}\n}).call(this);\n"
 
   # Compile the expressions body for the contents of a function, with
@@ -245,22 +250,26 @@ exports.Expressions = class Expressions extends Base
     o = merge(o, level: LEVEL_TOP)
     if i
       rest = @expressions.splice i, @expressions.length
-      code = @compileNode o
+      code = @compileNode(o)
       @expressions = rest
     post = @compileNode o
     {scope} = o
     if scope.expressions is this
-      if not o.globals and o.scope.hasDeclarations()
+      declars = o.scope.hasDeclarations()
+      assigns = scope.hasAssignments
+      if (declars or assigns) and i
+        code += '\n'
+      if declars
         code += "#{@tab}var #{ scope.declaredVariables().join(', ') };\n"
-      if scope.hasAssignments
+      if assigns
         code += "#{@tab}var #{ multident scope.assignedVariables().join(', '), @tab };\n"
     code + post
 
-  # Wrap up the given nodes as an **Expressions**, unless it already happens
+  # Wrap up the given nodes as a **Block**, unless it already happens
   # to be one.
   @wrap: (nodes) ->
-    return nodes[0] if nodes.length is 1 and nodes[0] instanceof Expressions
-    new Expressions nodes
+    return nodes[0] if nodes.length is 1 and nodes[0] instanceof Block
+    new Block nodes
 
 #### Literal
 
@@ -289,7 +298,12 @@ exports.Literal = class Literal extends Base
     if not (o and (o.loop or o.block and (@value isnt 'continue'))) then this else no
 
   compileNode: (o) ->
-    code = if @value.reserved then "\"#{@value}\"" else @value
+    code = if @isUndefined
+      if o.level >= LEVEL_ACCESS then '(void 0)' else 'void 0'
+    else if @value.reserved
+      "\"#{@value}\""
+    else
+      @value
     if @isStatement() then "#{@tab}#{code};" else code
 
   toString: ->
@@ -300,7 +314,8 @@ exports.Literal = class Literal extends Base
 # A `return` is a *pureStatement* -- wrapping it in a closure wouldn't
 # make sense.
 exports.Return = class Return extends Base
-  constructor: (@expression) ->
+  constructor: (expr) ->
+    @expression = expr if expr and not expr.unwrap().isUndefined
 
   children: ['expression']
 
@@ -373,7 +388,7 @@ exports.Value = class Value extends Base
     name = last @properties
     if @properties.length < 2 and not @base.isComplex() and not name?.isComplex()
       return [this, this]  # `a` `a.b`
-    base = new Value @base, @properties.slice 0, -1
+    base = new Value @base, @properties[...-1]
     if base.isComplex()  # `a().b`
       bref = new Literal o.scope.freeVariable 'base'
       base = new Value new Parens new Assign bref, base
@@ -392,25 +407,28 @@ exports.Value = class Value extends Base
     @base.front = @front
     props = @properties
     code  = @base.compile o, if props.length then LEVEL_ACCESS else null
-    code  = "(#{code})" if props[0] instanceof Access and @isSimpleNumber()
+    code  = "#{code}." if (@base instanceof Parens or props.length) and SIMPLENUM.test code
     code += prop.compile o for prop in props
     code
 
   # Unfold a soak into an `If`: `a?.b` -> `a.b if a?`
   unfoldSoak: (o) ->
-    if ifn = @base.unfoldSoak o
-      Array::push.apply ifn.body.properties, @properties
-      return ifn
-    for prop, i in @properties when prop.soak
-      prop.soak = off
-      fst = new Value @base, @properties.slice 0, i
-      snd = new Value @base, @properties.slice i
-      if fst.isComplex()
-        ref = new Literal o.scope.freeVariable 'ref'
-        fst = new Parens new Assign ref, fst
-        snd.base = ref
-      return new If new Existence(fst), snd, soak: on
-    null
+    return @unfoldedSoak if @unfoldedSoak?
+    result = do =>
+      if ifn = @base.unfoldSoak o
+        Array::push.apply ifn.body.properties, @properties
+        return ifn
+      for prop, i in @properties when prop.soak
+        prop.soak = off
+        fst = new Value @base, @properties[...i]
+        snd = new Value @base, @properties[i..]
+        if fst.isComplex()
+          ref = new Literal o.scope.freeVariable 'ref'
+          fst = new Parens new Assign ref, fst
+          snd.base = ref
+        return new If new Existence(fst), snd, soak: on
+      null
+    @unfoldedSoak = result or no
 
 #### Comment
 
@@ -442,7 +460,7 @@ exports.Call = class Call extends Base
   # Tag this invocation as creating a new instance.
   newInstance: ->
     base = @variable.base or @variable
-    if base instanceof Call
+    if base instanceof Call and not base.isNew
       base.newInstance()
     else
       @isNew = true
@@ -454,9 +472,9 @@ exports.Call = class Call extends Base
     {method} = o.scope
     throw SyntaxError 'cannot call super outside of a function.' unless method
     {name} = method
-    throw SyntaxError 'cannot call super on an anonymous function.' unless name
+    throw SyntaxError 'cannot call super on an anonymous function.' unless name?
     if method.klass
-      "#{method.klass}.__super__.#{name}"
+      (new Value (new Literal method.klass), [new Access(new Literal "__super__"), new Access new Literal name]).compile o
     else
       "#{name}.__super__.constructor"
 
@@ -492,12 +510,31 @@ exports.Call = class Call extends Base
       ifn = unfoldSoak o, call, 'variable'
     ifn
 
+  # Walk through the objects in the arguments, moving over simple values.
+  # This allows syntax like `call a: b, c` into `call({a: b}, c);`
+  filterImplicitObjects: (list) ->
+    nodes = []
+    for node in list
+      unless node.isObject?() and node.base.generated
+        nodes.push node
+        continue
+      obj = null
+      for prop in node.base.properties
+        if prop instanceof Assign or prop instanceof Comment
+          nodes.push obj = new Obj properties = [], true if not obj
+          properties.push prop
+        else
+          nodes.push prop
+          obj = null
+    nodes
+
   # Compile a vanilla function call.
   compileNode: (o) ->
     @variable?.front = @front
     if code = Splat.compileSplattedArray o, @args, true
       return @compileSplat o, code
-    args = (arg.compile o, LEVEL_LIST for arg in @args).join ', '
+    args = @filterImplicitObjects @args
+    args = (arg.compile o, LEVEL_LIST for arg in args).join ', '
     if @isSuper
       @superReference(o) + ".call(this#{ args and ', ' + args })"
     else
@@ -517,11 +554,11 @@ exports.Call = class Call extends Base
     if @isNew
       idt = @tab + TAB
       return """
-		(function(func, args, ctor) {
-		#{idt}ctor.prototype = func.prototype;
-		#{idt}var child = new ctor, result = func.apply(child, args);
-		#{idt}return typeof result === "object" ? result : child;
-		#{@tab}})(#{ @variable.compile o, LEVEL_LIST }, #{splatArgs}, function() {})
+        (function(func, args, ctor) {
+        #{idt}ctor.prototype = func.prototype;
+        #{idt}var child = new ctor, result = func.apply(child, args);
+        #{idt}return typeof result === "object" ? result : child;
+        #{@tab}})(#{ @variable.compile o, LEVEL_LIST }, #{splatArgs}, function() {})
       """
     base = new Value @variable
     if (name = base.properties.pop()) and base.isComplex()
@@ -529,6 +566,7 @@ exports.Call = class Call extends Base
       fun = "(#{ref} = #{ base.compile o, LEVEL_LIST })#{ name.compile o }"
     else
       fun = base.compile o, LEVEL_ACCESS
+      fun = "(#{fun})" if SIMPLENUM.test fun
       if name
         ref = fun
         fun += name.compile o
@@ -565,7 +603,7 @@ exports.Access = class Access extends Base
 
   compile: (o) ->
     name = @name.compile o
-    @proto + if IS_STRING.test name then "[#{name}]" else ".#{name}"
+    @proto + if IDENTIFIER.test name then ".#{name}" else "[#{name}]"
 
   isComplex: NO
 
@@ -599,39 +637,48 @@ exports.Range = class Range extends Base
   # Compiles the range's source variables -- where it starts and where it ends.
   # But only if they need to be cached to avoid double evaluation.
   compileVariables: (o) ->
-    o = merge(o, top: true)
-    [@from, @fromVar] =  @from.cache o, LEVEL_LIST
-    [@to, @toVar] =      @to.cache o, LEVEL_LIST
-    [@fromNum, @toNum] = [@fromVar.match(SIMPLENUM), @toVar.match(SIMPLENUM)]
-    parts = []
-    parts.push @from if @from isnt @fromVar
-    parts.push @to if @to isnt @toVar
+    o = merge o, top: true
+    [@fromC, @fromVar]  =  @from.cache o, LEVEL_LIST
+    [@toC, @toVar]      =  @to.cache o, LEVEL_LIST
+    [@step, @stepVar]   =  step.cache o, LEVEL_LIST if step = del o, 'step'
+    [@fromNum, @toNum]  = [@fromVar.match(SIMPLENUM), @toVar.match(SIMPLENUM)]
+    @stepNum            = @stepVar.match(SIMPLENUM) if @stepVar
 
   # When compiled normally, the range returns the contents of the *for loop*
   # needed to iterate over the values in the range. Used by comprehensions.
   compileNode: (o) ->
-    @compileVariables o
-    return    @compileArray(o)  unless o.index
-    return    @compileSimple(o) if @fromNum and @toNum
-    idx      = del o, 'index'
-    step     = del o, 'step'
-    vars     = "#{idx} = #{@from}" + if @to isnt @toVar then ", #{@to}" else ''
-    intro    = "(#{@fromVar} <= #{@toVar} ? #{idx}"
-    compare  = "#{intro} <#{@equals} #{@toVar} : #{idx} >#{@equals} #{@toVar})"
-    stepPart = if step then step.compile(o) else '1'
-    incr     = if step then "#{idx} += #{stepPart}" else "#{intro} += #{stepPart} : #{idx} -= #{stepPart})"
-    "#{vars}; #{compare}; #{incr}"
+    @compileVariables o unless @fromVar
+    return @compileArray(o) unless o.index
 
-  # Compile a simple range comprehension, with integers.
-  compileSimple: (o) ->
-    [from, to] = [+@fromNum, +@toNum]
-    idx        = del o, 'index'
-    step       = del o, 'step'
-    step       and= "#{idx} += #{step.compile(o)}"
-    if from <= to
-      "#{idx} = #{from}; #{idx} <#{@equals} #{to}; #{step or "#{idx}++"}"
+    # Set up endpoints.
+    known    = @fromNum and @toNum
+    idx      = del o, 'index'
+    varPart  = "#{idx} = #{@fromC}"
+    varPart += ", #{@toC}" if @toC isnt @toVar
+    varPart += ", #{@step}" if @step isnt @stepVar
+    [lt, gt] = ["#{idx} <#{@equals}", "#{idx} >#{@equals}"]
+
+    # Generate the condition.
+    condPart = if @stepNum
+      condPart = if +@stepNum > 0 then "#{lt} #{@toVar}" else "#{gt} #{@toVar}"
+    else if known
+      [from, to] = [+@fromNum, +@toNum]
+      condPart   = if from <= to then "#{lt} #{to}" else "#{gt} #{to}"
     else
-      "#{idx} = #{from}; #{idx} >#{@equals} #{to}; #{step or "#{idx}--"}"
+      cond     = "#{@fromVar} <= #{@toVar}"
+      condPart = "#{cond} ? #{lt} #{@toVar} : #{gt} #{@toVar}"
+
+    # Generate the step.
+    stepPart = if @stepVar
+      "#{idx} += #{@stepVar}"
+    else if known
+      if from <= to then "#{idx}++" else "#{idx}--"
+    else
+      "#{cond} ? #{idx}++ : #{idx}--"
+
+    # The final loop body.
+    "#{varPart}; #{condPart}; #{stepPart}"
+
 
   # When used as a value, expand the range into the equivalent array.
   compileArray: (o) ->
@@ -645,13 +692,15 @@ exports.Range = class Range extends Base
     pre    = "\n#{idt}#{result} = [];"
     if @fromNum and @toNum
       o.index = i
-      body = @compileSimple o
+      body    = @compileNode o
     else
-      vars = "#{i} = #{@from}" + if @to isnt @toVar then ", #{@to}" else ''
-      clause = "#{@fromVar} <= #{@toVar} ?"
-      body   = "var #{vars}; #{clause} #{i} <#{@equals} #{@toVar} : #{i} >#{@equals} #{@toVar}; #{clause} #{i} += 1 : #{i} -= 1"
+      vars    = "#{i} = #{@fromC}" + if @toC isnt @toVar then ", #{@toC}" else ''
+      cond    = "#{@fromVar} <= #{@toVar}"
+      body    = "var #{vars}; #{cond} ? #{i} <#{@equals} #{@toVar} : #{i} >#{@equals} #{@toVar}; #{cond} ? #{i}++ : #{i}--"
     post   = "{ #{result}.push(#{i}); }\n#{idt}return #{result};\n#{o.indent}"
-    "(function() {#{pre}\n#{idt}for (#{body})#{post}}).call(this)"
+    hasArgs = (node) -> node?.contains (n) -> n instanceof Literal and n.value is 'arguments' and not n.asKey
+    args   = ', arguments' if hasArgs(@from) or hasArgs(@to)
+    "(function() {#{pre}\n#{idt}for (#{body})#{post}}).apply(this#{args ? ''})"
 
 #### Slice
 
@@ -693,6 +742,9 @@ exports.Obj = class Obj extends Base
   compileNode: (o) ->
     props = @properties
     return (if @front then '({})' else '{}') unless props.length
+    if @generated
+      for node in props when node instanceof Value
+        throw new Error 'cannot have an implicit value in an implicit object'
     idt         = o.indent += TAB
     lastNoncom  = @lastNonComment @properties
     props = for prop, i in props
@@ -727,11 +779,14 @@ exports.Arr = class Arr extends Base
 
   children: ['objects']
 
+  filterImplicitObjects: Call::filterImplicitObjects
+
   compileNode: (o) ->
     return '[]' unless @objects.length
     o.indent += TAB
-    return code if code = Splat.compileSplattedArray o, @objects
-    code = (obj.compile o, LEVEL_LIST for obj in @objects).join ', '
+    objs = @filterImplicitObjects @objects
+    return code if code = Splat.compileSplattedArray o, objs
+    code = (obj.compile o, LEVEL_LIST for obj in objs).join ', '
     if code.indexOf('\n') >= 0
       "[\n#{o.indent}#{code}\n#{@tab}]"
     else
@@ -747,7 +802,7 @@ exports.Arr = class Arr extends Base
 # Initialize a **Class** with its name, an optional superclass, and a
 # list of prototype property assignments.
 exports.Class = class Class extends Base
-  constructor: (@variable, @parent, @body = new Expressions) ->
+  constructor: (@variable, @parent, @body = new Block) ->
     @boundFuncs = []
     @body.classBody = yes
 
@@ -778,14 +833,14 @@ exports.Class = class Class extends Base
   addBoundFunctions: (o) ->
     if @boundFuncs.length
       for bvar in @boundFuncs
-        bname = bvar.compile o
-        @ctor.body.unshift new Literal "this.#{bname} = #{utility 'bind'}(this.#{bname}, this);"
+        lhs = (new Value (new Literal "this"), [new Access bvar]).compile o
+        @ctor.body.unshift new Literal "#{lhs} = #{utility 'bind'}(#{lhs}, this)"
 
   # Merge the properties from a top-level object as prototypal properties
   # on the class.
-  addProperties: (node, name) ->
-    props = node.base.properties.slice 0
-    while assign = props.shift()
+  addProperties: (node, name, o) ->
+    props = node.base.properties[0..]
+    exprs = while assign = props.shift()
       if assign instanceof Assign
         base = assign.variable.base
         delete assign.context
@@ -798,7 +853,8 @@ exports.Class = class Class extends Base
           if func instanceof Code
             assign = @ctor = func
           else
-            assign = @ctor = new Assign(new Value(new Literal name), func)
+            @externalCtor = o.scope.freeVariable 'class'
+            assign = new Assign new Literal(@externalCtor), func
         else
           unless assign.variable.this
             assign.variable = new Value(new Literal(name), [new Access(base, 'proto')])
@@ -806,15 +862,16 @@ exports.Class = class Class extends Base
             @boundFuncs.push base
             func.bound = no
       assign
+    compact exprs
 
   # Walk the body of the class, looking for prototype properties to be converted.
-  walkBody: (name) ->
+  walkBody: (name, o) ->
     @traverseChildren false, (child) =>
       return false if child instanceof Class
-      if child instanceof Expressions
+      if child instanceof Block
         for node, i in exps = child.expressions
           if node instanceof Value and node.isObject(true)
-            exps[i] = @addProperties node, name
+            exps[i] = @addProperties node, name, o
         child.expressions = exps = flatten exps
 
   # Make sure that a constructor is defined for the class, and properly
@@ -822,7 +879,8 @@ exports.Class = class Class extends Base
   ensureConstructor: (name) ->
     if not @ctor
       @ctor = new Code
-      @ctor.body.push new Call 'super', [new Splat new Literal 'arguments'] if @parent
+      @ctor.body.push new Literal "#{name}.__super__.constructor.apply(this, arguments)" if @parent
+      @ctor.body.push new Literal "#{@externalCtor}.apply(this, arguments)" if @externalCtor
       @body.expressions.unshift @ctor
     @ctor.ctor     = @ctor.name = name
     @ctor.klass    = null
@@ -837,9 +895,10 @@ exports.Class = class Class extends Base
     lname = new Literal name
 
     @setContext name
-    @walkBody name
-    @body.expressions.unshift new Extends lname, @parent if @parent
+    @walkBody name, o
     @ensureConstructor name
+    @body.expressions.unshift new Extends lname, @parent if @parent
+    @body.expressions.unshift @ctor unless @ctor instanceof Code
     @body.expressions.push lname
     @addBoundFunctions o
 
@@ -855,11 +914,11 @@ exports.Assign = class Assign extends Base
   constructor: (@variable, @value, @context, options) ->
     @param = options and options.param
 
-  # Matchers for detecting class/method names
-  METHOD_DEF: /^(?:(\S+)\.prototype\.|\S+?)?\b([$A-Za-z_][$\w]*)$/
-
   children: ['variable', 'value']
 
+  isStatement: (o) ->
+    o?.level is LEVEL_TOP and @context? and "?" in @context
+
   assigns: (name) ->
     @[if @context is 'object' then 'value' else 'variable'].assigns name
 
@@ -876,18 +935,18 @@ exports.Assign = class Assign extends Base
       return @compileSplice       o if @variable.isSplice()
       return @compileConditional  o if @context in ['||=', '&&=', '?=']
     name = @variable.compile o, LEVEL_LIST
-    if @value instanceof Code and match = @METHOD_DEF.exec name
-      @value.name  = match[2]
-      @value.klass = match[1] if match[1]
-    val = @value.compile o, LEVEL_LIST
-    return "#{name}: #{val}" if @context is 'object'
-    unless @variable.isAssignable()
+    unless @context or @variable.isAssignable()
       throw SyntaxError "\"#{ @variable.compile o }\" cannot be assigned."
     unless @context or isValue and (@variable.namespaced or @variable.hasProperties())
       if @param
         o.scope.add name, 'var'
       else
         o.scope.find name
+    if @value instanceof Code and match = METHOD_DEF.exec name
+      @value.klass = match[1] if match[1]
+      @value.name  = match[2] ? match[3] ? match[4] ? match[5]
+    val = @value.compile o, LEVEL_LIST
+    return "#{name}: #{val}" if @context is 'object'
     val = name + " #{ @context or '=' } " + val
     if o.level <= LEVEL_LIST then val else "(#{val})"
 
@@ -899,7 +958,9 @@ exports.Assign = class Assign extends Base
     top       = o.level is LEVEL_TOP
     {value}   = this
     {objects} = @variable.base
-    return value.compile o unless olen = objects.length
+    unless olen = objects.length
+      code = value.compile o
+      return if o.level >= LEVEL_OP then "(#{code})" else code
     isObject = @variable.isObject()
     if top and olen is 1 and (obj = objects[0]) not instanceof Splat
       # Unroll simplest cases: `{v} = x` -> `v = x.v`
@@ -916,7 +977,7 @@ exports.Assign = class Assign extends Base
       acc   = IDENTIFIER.test idx.unwrap().value or 0
       value = new Value value
       value.properties.push new (if acc then Access else Index) idx
-      return new Assign(obj, value).compile o
+      return new Assign(obj, value, null, param: @param).compile o, LEVEL_TOP
     vvar    = value.compile o, LEVEL_LIST
     assigns = []
     splat   = false
@@ -966,7 +1027,8 @@ exports.Assign = class Assign extends Base
   # more than once.
   compileConditional: (o) ->
     [left, rite] = @variable.cacheReference o
-    new Op(@context.slice(0, -1), left, new Assign(rite, @value, '=')).compile o
+    if "?" in @context then o.isExistentialEquals = true
+    new Op(@context[0...-1], left, new Assign(rite, @value, '=') ).compile o
 
   # Compile the assignment from an array splice literal, using JavaScript's
   # `Array#splice` method.
@@ -995,7 +1057,7 @@ exports.Assign = class Assign extends Base
 exports.Code = class Code extends Base
   constructor: (params, body, tag) ->
     @params  = params or []
-    @body    = body or new Expressions
+    @body    = body or new Block
     @bound   = tag is 'boundfunc'
     @context = 'this' if @bound
 
@@ -1007,7 +1069,7 @@ exports.Code = class Code extends Base
 
   # 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 `arguments` objects. If the function is bound with the `=>`
+  # the JavaScript `arguments` object. If the function is bound with the `=>`
   # arrow, generates a wrapper that saves the current value of `this` through
   # a closure.
   compileNode: (o) ->
@@ -1015,10 +1077,10 @@ exports.Code = class Code extends Base
     o.scope.shared  = del o, 'sharedScope'
     o.indent        += TAB
     delete o.bare
-    delete o.globals
     vars   = []
     exprs  = []
     for param in @params when param.splat
+      o.scope.add p.name.value, 'var', yes for p in @params when p.name.value
       splats = new Assign new Value(new Arr(p.asReference o for p in @params)),
                           new Value new Literal 'arguments'
       break
@@ -1101,7 +1163,7 @@ exports.Splat = class Splat extends Base
   compile: (o) ->
     if @index? then @compileParam o else @name.compile o
 
-  # Utility function that converts arbitrary number of elements, mixed with
+  # Utility function that converts an arbitrary number of elements, mixed with
   # splats, to a proper array.
   @compileSplattedArray: (o, list, apply) ->
     index = -1
@@ -1111,14 +1173,14 @@ exports.Splat = class Splat extends Base
       code = list[0].compile o, LEVEL_LIST
       return code if apply
       return "#{ utility 'slice' }.call(#{code})"
-    args = list.slice index
+    args = list[index..]
     for node, i in args
       code = node.compile o, LEVEL_LIST
       args[i] = if node instanceof Splat
       then "#{ utility 'slice' }.call(#{code})"
       else "[#{code}]"
-    return args[0] + ".concat(#{ args.slice(1).join ', ' })" if index is 0
-    base = (node.compile o, LEVEL_LIST for node in list.slice 0, index)
+    return args[0] + ".concat(#{ args[1..].join ', ' })" if index is 0
+    base = (node.compile o, LEVEL_LIST for node in list[0...index])
     "[#{ base.join ', ' }].concat(#{ args.join ', ' })"
 
 #### While
@@ -1163,7 +1225,7 @@ exports.While = class While extends Base
         rvar = o.scope.freeVariable 'results'
         set  = "#{@tab}#{rvar} = [];\n"
         body = Push.wrap rvar, body if body
-      body = Expressions.wrap [new If @guard, body] if @guard
+      body = Block.wrap [new If @guard, body] if @guard
       body = "\n#{ body.compile o, LEVEL_TOP }\n#{@tab}"
     code = set + @tab + "while (#{ @condition.compile o, LEVEL_PAREN }) {#{body}}"
     if @returns
@@ -1175,12 +1237,15 @@ exports.While = class While extends Base
 # Simple Arithmetic and logical operations. Performs some conversion from
 # CoffeeScript operations into their JavaScript equivalents.
 exports.Op = class Op extends Base
-  constructor: (op, first, second, flip) ->
+  constructor: (op, first, second, flip ) ->
     return new In first, second if op is 'in'
-    return new Call first, first.params or [] if op is 'do'
+    if op is 'do'
+      call = new Call first, first.params or []
+      call.do = yes
+      return call
     if op is 'new'
-      return first.newInstance() if first instanceof Call
-      first = new Parens first   if first instanceof Code and first.bound
+      return first.newInstance() if first instanceof Call and not first.do and not first.isNew
+      first = new Parens first   if first instanceof Code and first.bound or first.do
     @operator = CONVERSIONS[op] or op
     @first    = first
     @second   = second
@@ -1205,6 +1270,9 @@ exports.Op = class Op extends Base
   isUnary: ->
     not @second
 
+  isComplex: ->
+    not (@isUnary() and (@operator in ['+', '-'])) or @first.isComplex()
+
   # Am I capable of
   # [Python-style comparison chaining](http://docs.python.org/reference/expressions.html#notin)?
   isChainable: ->
@@ -1262,18 +1330,19 @@ exports.Op = class Op extends Base
 
   compileExistence: (o) ->
     if @first.isComplex()
-      ref = o.scope.freeVariable 'ref'
-      fst = new Parens new Assign new Literal(ref), @first
+      ref = new Literal o.scope.freeVariable 'ref'
+      fst = new Parens new Assign ref, @first
     else
       fst = @first
-      ref = fst.compile o
-    new Existence(fst).compile(o) + " ? #{ref} : #{ @second.compile o, LEVEL_LIST }"
+      ref = fst
+    new If(new Existence(fst), ref, type: 'if').addElse(@second).compile o
 
   # Compile a unary **Op**.
   compileUnary: (o) ->
     parts = [op = @operator]
     parts.push ' ' if op in ['new', 'typeof', 'delete'] or
                       op in ['+', '-'] and @first instanceof Op and @first.operator is op
+    @first = new Parens @first if op is 'new' and @first.isStatement o
     parts.push @first.compile o, LEVEL_OP
     parts.reverse() if @flip
     parts.join ''
@@ -1291,15 +1360,19 @@ exports.In = class In extends Base
 
   compileNode: (o) ->
     if @array instanceof Value and @array.isArray()
-      @compileOrTest o
-    else
-      @compileLoopTest o
+      for obj in @array.base.objects when obj instanceof Splat
+        hasSplat = yes
+        break
+      # `compileOrTest` only if we have an array literal with no splats
+      return @compileOrTest o unless hasSplat
+    @compileLoopTest o
 
   compileOrTest: (o) ->
     [sub, ref] = @object.cache o, LEVEL_OP
     [cmp, cnj] = if @negated then [' !== ', ' && '] else [' === ', ' || ']
     tests = for item, i in @array.base.objects
       (if i then ref else sub) + cmp + item.compile o, LEVEL_OP
+    return 'false' if tests.length is 0
     tests = tests.join cnj
     if o.level < LEVEL_OP then tests else "(#{tests})"
 
@@ -1337,6 +1410,7 @@ exports.Try = class Try extends Base
     o.indent  += TAB
     errorPart = if @error then " (#{ @error.compile o }) " else ' '
     catchPart = if @recovery
+      o.scope.add @error.value, 'param'
       " catch#{errorPart}{\n#{ @recovery.compile o, LEVEL_TOP }\n#{@tab}}"
     else unless @ensure or @recovery
       ' catch (_e) {}'
@@ -1378,13 +1452,11 @@ exports.Existence = class Existence extends Base
   compileNode: (o) ->
     code = @expression.compile o, LEVEL_OP
     code = if IDENTIFIER.test(code) and not o.scope.check code
-      if @negated
-        "typeof #{code} == \"undefined\" || #{code} === null"
-      else
-        "typeof #{code} != \"undefined\" && #{code} !== null"
+        [cmp, cnj] = if @negated then ['===', '||'] else ['!==', '&&']
+        "typeof #{code} #{cmp} \"undefined\" #{cnj} #{code} #{cmp} null"
     else
-      sym = if @negated then '==' else '!='
-      "#{code} #{sym} null"
+      # do not use strict equality here; it will break existing code
+      "#{code} #{if @negated then '==' else '!='} null"
     if o.level <= LEVEL_COND then code else "(#{code})"
 
 #### Parens
@@ -1425,7 +1497,7 @@ exports.Parens = class Parens extends Base
 exports.For = class For extends Base
   constructor: (body, source) ->
     {@source, @guard, @step, @name, @index} = source
-    @body    = Expressions.wrap [body]
+    @body    = Block.wrap [body]
     @own     = !!source.own
     @object  = !!source.object
     [@name, @index] = [@index, @name] if @object
@@ -1451,50 +1523,53 @@ exports.For = class For extends Base
   # comprehensions. Some of the generated code can be shared in common, and
   # some cannot.
   compileNode: (o) ->
-    body          = Expressions.wrap [@body]
-    lastJumps     = last(body.expressions)?.jumps()
-    @returns      = no if lastJumps and lastJumps instanceof Return
-    source        = if @range then @source.base else @source
-    scope         = o.scope
-    name          = @name  and @name.compile o, LEVEL_LIST
-    index         = @index and @index.compile o, LEVEL_LIST
+    body      = Block.wrap [@body]
+    lastJumps = last(body.expressions)?.jumps()
+    @returns  = no if lastJumps and lastJumps instanceof Return
+    source    = if @range then @source.base else @source
+    scope     = o.scope
+    name      = @name  and @name.compile o, LEVEL_LIST
+    index     = @index and @index.compile o, LEVEL_LIST
     scope.find(name,  immediate: yes) if name and not @pattern
     scope.find(index, immediate: yes) if index
-    rvar          = scope.freeVariable 'results' if @returns
-    ivar          = (if @range then name else index) or scope.freeVariable 'i'
-    name          = ivar if @pattern
-    varPart       = ''
-    guardPart     = ''
-    defPart       = ''
-    idt1          = @tab + TAB
+    rvar      = scope.freeVariable 'results' if @returns
+    ivar      = (if @range then name else index) or scope.freeVariable 'i'
+    # the `_by` variable is created twice in `Range`s if we don't prevent it from being declared here
+    stepvar   = scope.freeVariable "step" if @step and not @range
+    name      = ivar if @pattern
+    varPart   = ''
+    guardPart = ''
+    defPart   = ''
+    idt1      = @tab + TAB
     if @range
       forPart = source.compile merge(o, {index: ivar, @step})
     else
-      svar = @source.compile o, LEVEL_LIST
+      svar    = @source.compile o, LEVEL_LIST
       if (name or @own) and not IDENTIFIER.test svar
-        defPart = "#{@tab}#{ref = scope.freeVariable 'ref'} = #{svar};\n"
-        svar = ref
+        defPart    = "#{@tab}#{ref = scope.freeVariable 'ref'} = #{svar};\n"
+        svar       = ref
       if name and not @pattern
-        namePart = "#{name} = #{svar}[#{ivar}]"
+        namePart   = "#{name} = #{svar}[#{ivar}]"
       unless @object
-        lvar        = scope.freeVariable 'len'
-        stepPart    = if @step then "#{ivar} += #{ @step.compile(o, LEVEL_OP) }" else "#{ivar}++"
-        forPart     = "#{ivar} = 0, #{lvar} = #{svar}.length; #{ivar} < #{lvar}; #{stepPart}"
+        lvar       = scope.freeVariable 'len'
+        forVarPart = "#{ivar} = 0, #{lvar} = #{svar}.length" + if @step then ", #{stepvar} = #{@step.compile(o, LEVEL_OP)}" else ''
+        stepPart   = if @step then "#{ivar} += #{stepvar}" else "#{ivar}++"
+        forPart    = "#{forVarPart}; #{ivar} < #{lvar}; #{stepPart}"
     if @returns
-      resultPart    = "#{@tab}#{rvar} = [];\n"
-      returnResult  = "\n#{@tab}return #{rvar};"
-      body          = Push.wrap rvar, body
+      resultPart   = "#{@tab}#{rvar} = [];\n"
+      returnResult = "\n#{@tab}return #{rvar};"
+      body         = Push.wrap rvar, body
     if @guard
-      body          = Expressions.wrap [new If @guard, body]
+      body         = Block.wrap [new If @guard, body]
     if @pattern
       body.expressions.unshift new Assign @name, new Literal "#{svar}[#{ivar}]"
-    defPart         += @pluckDirectCall o, body
-    varPart         = "\n#{idt1}#{namePart};" if namePart
+    defPart     += @pluckDirectCall o, body
+    varPart     = "\n#{idt1}#{namePart};" if namePart
     if @object
-      forPart       = "#{ivar} in #{svar}"
-      guardPart     = "\n#{idt1}if (!#{utility('hasProp')}.call(#{svar}, #{ivar})) continue;" if @own
-    body            = body.compile merge(o, indent: idt1), LEVEL_TOP
-    body            = '\n' + body + '\n' if body
+      forPart   = "#{ivar} in #{svar}"
+      guardPart = "\n#{idt1}if (!#{utility('hasProp')}.call(#{svar}, #{ivar})) continue;" if @own
+    body        = body.compile merge(o, indent: idt1), LEVEL_TOP
+    body        = '\n' + body + '\n' if body
     """
     #{defPart}#{resultPart or ''}#{@tab}for (#{forPart}) {#{guardPart}#{varPart}#{body}#{@tab}}#{returnResult or ''}
     """
@@ -1515,7 +1590,6 @@ exports.For = class For extends Base
       base  = new Value ref
       if val.base
         [val.base, base] = [base, val]
-        args.unshift new Literal 'this'
       body.expressions[idx] = new Call base, expr.args
       defs += @tab + new Assign(ref, fn).compile(o, LEVEL_TOP) + ';\n'
     defs
@@ -1551,9 +1625,8 @@ exports.Switch = class Switch extends Base
       code += body + '\n' if body = block.compile o, LEVEL_TOP
       break if i is @cases.length - 1 and not @otherwise
       expr = @lastNonComment block.expressions
-      jumper = expr.jumps()
-      if not expr or not jumper or (jumper instanceof Literal and jumper.value is 'debugger')
-        code += idt2 + 'break;\n'
+      continue if expr instanceof Return or (expr instanceof Literal and expr.jumps() and expr.value isnt 'debugger')
+      code += idt2 + 'break;\n'
     code += idt1 + "default:\n#{ @otherwise.compile o, LEVEL_TOP }\n" if @otherwise and @otherwise.expressions.length
     code +  @tab + '}'
 
@@ -1582,7 +1655,7 @@ exports.If = class If extends Base
       @elseBodyNode().addElse elseBody
     else
       @isChain  = elseBody instanceof If
-      @elseBody = @ensureExpressions elseBody
+      @elseBody = @ensureBlock elseBody
     this
 
   # The **If** only compiles into a statement if either of its bodies needs
@@ -1597,20 +1670,25 @@ exports.If = class If extends Base
     if @isStatement o then @compileStatement o else @compileExpression o
 
   makeReturn: ->
-    @body     and= new Expressions [@body.makeReturn()]
-    @elseBody and= new Expressions [@elseBody.makeReturn()]
+    @body     and= new Block [@body.makeReturn()]
+    @elseBody and= new Block [@elseBody.makeReturn()]
     this
 
-  ensureExpressions: (node) ->
-    if node instanceof Expressions then node else new Expressions [node]
+  ensureBlock: (node) ->
+    if node instanceof Block then node else new Block [node]
 
-  # Compile the **If** as a regular *if-else* statement. Flattened chains
+  # Compile the `If` as a regular *if-else* statement. Flattened chains
   # force inner *else* bodies into statement form.
   compileStatement: (o) ->
     child    = del o, 'chainChild'
+    exeq     = del o, 'isExistentialEquals'
+
+    if exeq
+      return new If(@condition.invert(), @elseBodyNode(), type: 'if').compile o
+
     cond     = @condition.compile o, LEVEL_PAREN
     o.indent += TAB
-    body     = @ensureExpressions(@body).compile o
+    body     = @ensureBlock(@body).compile o
     body     = "\n#{body}\n#{@tab}" if body
     ifPart   = "if (#{cond}) {#{body}}"
     ifPart   = @tab + ifPart unless child
@@ -1622,7 +1700,7 @@ exports.If = class If extends Base
     else
       "{\n#{ @elseBody.compile o, LEVEL_TOP }\n#{@tab}}"
 
-  # Compile the If as a conditional operator.
+  # Compile the `If` as a conditional operator.
   compileExpression: (o) ->
     cond = @condition.compile o, LEVEL_COND
     body = @bodyNode().compile o, LEVEL_LIST
@@ -1657,17 +1735,16 @@ Closure =
   # then make sure that the closure wrapper preserves the original values.
   wrap: (expressions, statement, noReturn) ->
     return expressions if expressions.jumps()
-    func = new Code [], Expressions.wrap [expressions]
+    func = new Code [], Block.wrap [expressions]
     args = []
-    if (mentionsArgs = expressions.contains @literalArgs) or
-       (               expressions.contains @literalThis)
+    if (mentionsArgs = expressions.contains @literalArgs) or expressions.contains @literalThis
       meth = new Literal if mentionsArgs then 'apply' else 'call'
       args = [new Literal 'this']
       args.push new Literal 'arguments' if mentionsArgs
       func = new Value func, [new Access meth]
     func.noReturn = noReturn
     call = new Call func, args
-    if statement then Expressions.wrap [call] else call
+    if statement then Block.wrap [call] else call
 
   literalArgs: (node) ->
     node instanceof Literal and node.value is 'arguments' and not node.asKey
@@ -1719,7 +1796,7 @@ UTILITIES =
   hasProp: 'Object.prototype.hasOwnProperty'
   slice  : 'Array.prototype.slice'
 
-# Levels indicates a node's position in the AST. Useful for knowing if
+# Levels indicate a node's position in the AST. Useful for knowing if
 # parens are necessary or superfluous.
 LEVEL_TOP    = 1  # ...;
 LEVEL_PAREN  = 2  # (...)
@@ -1731,12 +1808,24 @@ LEVEL_ACCESS = 6  # ...[0]
 # Tabs are two spaces for pretty printing.
 TAB = '  '
 
-# Trim out all trailing whitespace, so that the generated code plays nice
-# with Git.
-TRAILING_WHITESPACE = /[ \t]+$/gm
-
-IDENTIFIER = /^[$A-Za-z_][$\w]*$/
+IDENTIFIER_STR = "[$A-Za-z_\\x7f-\\uffff][$\\w\\x7f-\\uffff]*"
+IDENTIFIER = /// ^ #{IDENTIFIER_STR} $ ///
 SIMPLENUM  = /^[+-]?\d+$/
+METHOD_DEF = ///
+  ^
+    (?:
+      (#{IDENTIFIER_STR})
+      \.prototype
+      (?:
+        \.(#{IDENTIFIER_STR})
+      | \[("(?:[^\\"\r\n]|\\.)*"|'(?:[^\\'\r\n]|\\.)*')\]
+      | \[(0x[\da-fA-F]+ | \d*\.?\d+ (?:[eE][+-]?\d+)?)\]
+      )
+    )
+  |
+    (#{IDENTIFIER_STR})
+  $
+///
 
 # Is a literal value a string?
 IS_STRING = /^['"]/

src/optparse.coffee

@@ -17,7 +17,7 @@ exports.OptionParser = class OptionParser
     @rules = buildRules rules
 
   # Parse the list of arguments, populating an `options` object with all of the
-  # specified options, and returning it. `options.arguments` will be an array
+  # specified options, and return it. `options.arguments` will be an array
   # containing the remaining non-option arguments. `options.literals` will be
   # an array of options that are meant to be passed through directly to the
   # executing script. This is a simpler API than many option parsers that allow
@@ -47,7 +47,7 @@ exports.OptionParser = class OptionParser
   # Return the help text for this **OptionParser**, listing and describing all
   # of the valid options, for `--help` and such.
   help: ->
-    lines = ['Available options:']
+    lines = []
     lines.unshift "#{@banner}\n" if @banner
     for rule in @rules
       spaces  = 15 - rule.longFlag.length

src/repl.coffee

@@ -6,37 +6,128 @@
 
 # Require the **coffee-script** module to get access to the compiler.
 CoffeeScript = require './coffee-script'
-helpers      = require './helpers'
 readline     = require 'readline'
+{inspect}    = require 'util'
+{Script}     = require 'vm'
+Module       = require 'module'
 
-# Start by opening up **stdio**.
-stdio = process.openStdin()
+# REPL Setup
+
+# Config
+REPL_PROMPT = 'coffee> '
+REPL_PROMPT_CONTINUATION = '......> '
+enableColours = no
+unless process.platform is 'win32'
+  enableColours = not process.env.NODE_DISABLE_COLORS
+
+# Start by opening up `stdin` and `stdout`.
+stdin = process.openStdin()
+stdout = process.stdout
 
 # Log an error.
 error = (err) ->
-  stdio.write (err.stack or err.toString()) + '\n\n'
+  stdout.write (err.stack or err.toString()) + '\n\n'
 
-# Quick alias for quitting the REPL.
-helpers.extend global, quit: -> process.exit(0)
+# The current backlog of multi-line code.
+backlog = ''
+
+# The REPL context; must be visible outside `run` to allow for tab completion
+sandbox = Script.createContext()
+nonContextGlobals = [
+  'Buffer', 'console', 'process'
+  'setInterval', 'clearInterval'
+  'setTimeout', 'clearTimeout'
+]
+sandbox[g] = global[g] for g in nonContextGlobals
+sandbox.global = sandbox.root = sandbox.GLOBAL = sandbox
 
 # The main REPL function. **run** is called every time a line of code is entered.
 # Attempt to evaluate the command. If there's an exception, print it out instead
 # of exiting.
 run = (buffer) ->
+  if !buffer.toString().trim() and !backlog
+    repl.prompt()
+    return
+  code = backlog += buffer
+  if code[code.length - 1] is '\\'
+    backlog = "#{backlog[...-1]}\n"
+    repl.setPrompt REPL_PROMPT_CONTINUATION
+    repl.prompt()
+    return
+  repl.setPrompt REPL_PROMPT
+  backlog = ''
   try
-    val = CoffeeScript.eval buffer.toString(), bare: on, globals: on, fileName: 'repl'
-    console.log val if val isnt undefined
+    _ = sandbox._
+    returnValue = CoffeeScript.eval "_=(#{code}\n)", {
+      sandbox,
+      filename: 'repl'
+      modulename: 'repl'
+    }
+    if returnValue is undefined
+      sandbox._ = _
+    else
+      process.stdout.write inspect(returnValue, no, 2, enableColours) + '\n'
   catch err
     error err
   repl.prompt()
 
+## Autocompletion
+
+# Regexes to match complete-able bits of text.
+ACCESSOR  = /\s*([\w\.]+)(?:\.(\w*))$/
+SIMPLEVAR = /\s*(\w*)$/i
+
+# Returns a list of completions, and the completed text.
+autocomplete = (text) ->
+  completeAttribute(text) or completeVariable(text) or [[], text]
+
+# Attempt to autocomplete a chained dotted attribute: `one.two.three`.
+completeAttribute = (text) ->
+  if match = text.match ACCESSOR
+    [all, obj, prefix] = match
+    try
+      val = Script.runInContext obj, sandbox
+    catch error
+      return
+    completions = getCompletions prefix, Object.getOwnPropertyNames val
+    [completions, prefix]
+
+# Attempt to autocomplete an in-scope free variable: `one`.
+completeVariable = (text) ->
+  if free = (text.match SIMPLEVAR)?[1]
+    vars = Script.runInContext 'Object.getOwnPropertyNames(this)', sandbox
+    possibilities = vars.concat CoffeeScript.RESERVED
+    completions = getCompletions free, possibilities
+    [completions, free]
+
+# Return elements of candidates for which `prefix` is a prefix.
+getCompletions = (prefix, candidates) ->
+  (el for el in candidates when el.indexOf(prefix) is 0)
+
 # Make sure that uncaught exceptions don't kill the REPL.
 process.on 'uncaughtException', error
 
 # Create the REPL by listening to **stdin**.
-repl = readline.createInterface stdio
-repl.setPrompt 'coffee> '
-stdio.on 'data',   (buffer) -> repl.write buffer
-repl.on  'close',  -> stdio.destroy()
-repl.on  'line',   run
+if readline.createInterface.length < 3
+  repl = readline.createInterface stdin, autocomplete
+  stdin.on 'data', (buffer) -> repl.write buffer
+else
+  repl = readline.createInterface stdin, stdout, autocomplete
+
+repl.on 'attemptClose', ->
+  if backlog
+    backlog = ''
+    process.stdout.write '\n'
+    repl.setPrompt REPL_PROMPT
+    repl.prompt()
+  else
+    repl.close()
+
+repl.on 'close', ->
+  process.stdout.write '\n'
+  stdin.destroy()
+
+repl.on 'line', run
+
+repl.setPrompt REPL_PROMPT
 repl.prompt()

src/rewriter.coffee

@@ -104,7 +104,10 @@ class exports.Rewriter
         not (two?[0] is ':' or one?[0] is '@' and three?[0] is ':')) or
         (tag is ',' and one and
           one[0] not in ['IDENTIFIER', 'NUMBER', 'STRING', '@', 'TERMINATOR', 'OUTDENT'])
-    action = (token, i) -> @tokens.splice i, 0, ['}', '}', token[2]]
+    action = (token, i) ->
+      tok = ['}', '}', token[2]]
+      tok.generated = yes
+      @tokens.splice i, 0, tok
     @scanTokens (token, i, tokens) ->
       if (tag = token[0]) in EXPRESSION_START
         stack.push [(if tag is 'INDENT' and @tag(i - 1) is '{' then '{' else tag), i]
@@ -137,12 +140,14 @@ class exports.Rewriter
       tag     = token[0]
       noCall  = yes if tag in ['CLASS', 'IF']
       [prev, current, next] = tokens[i - 1 .. i + 1]
-      callObject = not noCall and tag is 'INDENT' and
-                   next and next.generated and next[0] is '{' and
-                   prev and prev[0] in IMPLICIT_FUNC
-      seenSingle = no
-      noCall     = no if tag in LINEBREAKS
-      token.call = yes if prev and not prev.spaced and tag is '?'
+      callObject  = not noCall and tag is 'INDENT' and
+                    next and next.generated and next[0] is '{' and
+                    prev and prev[0] in IMPLICIT_FUNC
+      seenSingle  = no
+      seenControl = no
+      noCall      = no if tag in LINEBREAKS
+      token.call  = yes if prev and not prev.spaced and tag is '?'
+      return 1 if token.fromThen
       return 1 unless callObject or
         prev?.spaced and (prev.call or prev[0] in IMPLICIT_FUNC) and
         (tag in IMPLICIT_CALL or not (token.spaced or token.newLine) and tag in IMPLICIT_UNSPACED_CALL)
@@ -150,9 +155,11 @@ class exports.Rewriter
       @detectEnd i + 1, (token, i) ->
         [tag] = token
         return yes if not seenSingle and token.fromThen
-        seenSingle = yes if tag in ['IF', 'ELSE', '->', '=>']
+        seenSingle  = yes if tag in ['IF', 'ELSE', 'CATCH', '->', '=>']
+        seenControl = yes if tag in ['IF', 'ELSE', 'SWITCH', 'TRY']
         return yes if tag in ['.', '?.', '::'] and @tag(i - 1) is 'OUTDENT'
-        not token.generated and @tag(i - 1) isnt ',' and tag in IMPLICIT_END and
+        not token.generated and @tag(i - 1) isnt ',' and (tag in IMPLICIT_END or
+        (tag is 'INDENT' and not seenControl)) and
         (tag isnt 'INDENT' or
          (@tag(i - 2) isnt 'CLASS' and @tag(i - 1) not in IMPLICIT_BLOCK and
           not ((post = @tokens[i + 1]) and post.generated and post[0] is '{')))
@@ -315,7 +322,7 @@ IMPLICIT_UNSPACED_CALL = ['+', '-']
 IMPLICIT_BLOCK   = ['->', '=>', '{', '[', ',']
 
 # Tokens that always mark the end of an implicit call for single-liners.
-IMPLICIT_END     = ['POST_IF', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR', 'INDENT']
+IMPLICIT_END     = ['POST_IF', 'FOR', 'WHILE', 'UNTIL', 'WHEN', 'BY', 'LOOP', 'TERMINATOR']
 
 # Single-line flavors of block expressions that have unclosed endings.
 # The grammar can't disambiguate them, so we insert the implicit indentation.

src/scope.coffee

@@ -14,10 +14,10 @@ exports.Scope = class Scope
   @root: null
 
   # Initialize a scope with its parent, for lookups up the chain,
-  # as well as a reference to the **Expressions** node is belongs to, which is
+  # as well as a reference to the **Block** node it belongs to, which is
   # where it should declare its variables, and a reference to the function that
   # it wraps.
-  constructor:(@parent, @expressions, @method) ->
+  constructor: (@parent, @expressions, @method) ->
     @variables = [{name: 'arguments', type: 'arguments'}]
     @positions = {}
     Scope.root = this unless @parent
@@ -66,7 +66,7 @@ exports.Scope = class Scope
   # compiler-generated variable. `_var`, `_var2`, and so on...
   freeVariable: (type) ->
     index = 0
-    index++ while @check((temp = @temporary type, index), true)
+    index++ while @check((temp = @temporary type, index))
     @add temp, 'var', yes
     temp
 

test/arrays.coffee

@@ -0,0 +1,77 @@
+# Array Literals
+# --------------
+
+# * Array Literals
+# * Splats in Array Literals
+
+# TODO: add indexing and method invocation tests: [1][0] is 1, [].toString()
+
+test "trailing commas", ->
+  trailingComma = [1, 2, 3,]
+  ok (trailingComma[0] is 1) and (trailingComma[2] is 3) and (trailingComma.length is 3)
+
+  trailingComma = [
+    1, 2, 3,
+    4, 5, 6
+    7, 8, 9,
+  ]
+  (sum = (sum or 0) + n) for n in trailingComma
+
+  a = [((x) -> x), ((x) -> x * x)]
+  ok a.length is 2
+
+test "incorrect indentation without commas", ->
+  result = [['a']
+   {b: 'c'}]
+  ok result[0][0] is 'a'
+  ok result[1]['b'] is 'c'
+
+
+# Splats in Array Literals
+
+test "array splat expansions with assignments", ->
+  nums = [1, 2, 3]
+  list = [a = 0, nums..., b = 4]
+  eq 0, a
+  eq 4, b
+  arrayEq [0,1,2,3,4], list
+
+
+test "mixed shorthand objects in array lists", ->
+
+  arr = [
+    a:1
+    'b'
+    c:1
+  ]
+  ok arr.length is 3
+  ok arr[2].c is 1
+
+  arr = [b: 1, a: 2, 100]
+  eq arr[1], 100
+
+  arr = [a:0, b:1, (1 + 1)]
+  eq arr[1], 2
+
+  arr = [a:1, 'a', b:1, 'b']
+  eq arr.length, 4
+  eq arr[2].b, 1
+  eq arr[3], 'b'
+
+
+test "array splats with nested arrays", ->
+  nonce = {}
+  a = [nonce]
+  list = [1, 2, a...]
+  eq list[0], 1
+  eq list[2], nonce
+
+  a = [[nonce]]
+  list = [1, 2, a...]
+  arrayEq list, [1, 2, [nonce]]
+
+test "#1274: `[] = a()` compiles to `false` instead of `a()`", ->
+  a = false
+  fn = -> a = true
+  [] = fn()
+  ok a

test/assignment.coffee

@@ -1,6 +1,12 @@
 # Assignment
 # ----------
 
+# * Assignment
+# * Compound Assignment
+# * Destructuring Assignment
+# * Context Property (@) Assignment
+# * Existential Assignment (?=)
+
 test "context property assignment (using @)", ->
   nonce = {}
   addMethod = ->
@@ -19,44 +25,80 @@ test "compound assignments should not declare", ->
   eq Math, (-> Math or= 0)()
 
 
-#### Statements as Expressions
+# Compound Assignment
 
-test "assign the result of a try/catch block", ->
-  # multiline
-  result = try
-    nonexistent * missing
-  catch error
-    true
-  eq true, result
-
-  # single line
-  result = try nonexistent * missing catch error then true
-  eq true, result
-
-test "conditionals", ->
-  # assign inside the condition of a conditional statement
+test "boolean operators", ->
   nonce = {}
-  if a = nonce then 1
+
+  a  = 0
+  a or= nonce
   eq nonce, a
-  1 if b = nonce
-  eq nonce, b
 
-  # assign the result of a conditional statement
-  c = if true then nonce
-  eq nonce, c
+  b  = 1
+  b or= nonce
+  eq 1, b
 
-test "assign inside the condition of a `while` loop", ->
-  nonce = {}
-  count = 1
-  a = nonce while count--
-  eq nonce, a
-  count = 1
-  while count--
-    b = nonce
-  eq nonce, b
+  c = 0
+  c and= nonce
+  eq 0, c
 
+  d = 1
+  d and= nonce
+  eq nonce, d
 
-#### Compound Assignment
+  # ensure that RHS is treated as a group
+  e = f = false
+  e and= f or true
+  eq false, e
+
+test "compound assignment as a sub expression", ->
+  [a, b, c] = [1, 2, 3]
+  eq 6, (a + b += c)
+  eq 1, a
+  eq 5, b
+  eq 3, c
+
+# *note: this test could still use refactoring*
+test "compound assignment should be careful about caching variables", ->
+  count = 0
+  list = []
+
+  list[++count] or= 1
+  eq 1, list[1]
+  eq 1, count
+
+  list[++count] ?= 2
+  eq 2, list[2]
+  eq 2, count
+
+  list[count++] and= 6
+  eq 6, list[2]
+  eq 3, count
+
+  base = ->
+    ++count
+    base
+
+  base().four or= 4
+  eq 4, base.four
+  eq 4, count
+
+  base().five ?= 5
+  eq 5, base.five
+  eq 5, count
+
+test "compound assignment with implicit objects", ->
+  obj = undefined
+  obj ?=
+    one: 1
+
+  eq 1, obj.one
+
+  obj and=
+    two: 2
+
+  eq undefined, obj.one
+  eq         2, obj.two
 
 test "compound assignment (math operators)", ->
   num = 10
@@ -92,7 +134,155 @@ test "more compound assignment", ->
   eq c, val
 
 
-#### Destructuring Assignment
+# Destructuring Assignment
 
-# NO TESTS?!
-# TODO: make tests for destructuring assignment
+test "empty destructuring assignment", ->
+  {} = [] = undefined
+
+test "chained destructuring assignments", ->
+  [a] = {0: b} = {'0': c} = [nonce={}]
+  eq nonce, a
+  eq nonce, b
+  eq nonce, c
+
+test "variable swapping to verify caching of RHS values when appropriate", ->
+  a = nonceA = {}
+  b = nonceB = {}
+  c = nonceC = {}
+  [a, b, c] = [b, c, a]
+  eq nonceB, a
+  eq nonceC, b
+  eq nonceA, c
+  [a, b, c] = [b, c, a]
+  eq nonceC, a
+  eq nonceA, b
+  eq nonceB, c
+  fn = ->
+    [a, b, c] = [b, c, a]
+  arrayEq [nonceA,nonceB,nonceC], fn()
+  eq nonceA, a
+  eq nonceB, b
+  eq nonceC, c
+
+test "#713", ->
+  nonces = [nonceA={},nonceB={}]
+  eq nonces, [a, b] = [c, d] = nonces
+  eq nonceA, a
+  eq nonceA, c
+  eq nonceB, b
+  eq nonceB, d
+
+test "destructuring assignment with splats", ->
+  a = {}; b = {}; c = {}; d = {}; e = {}
+  [x,y...,z] = [a,b,c,d,e]
+  eq a, x
+  arrayEq [b,c,d], y
+  eq e, z
+
+test "deep destructuring assignment with splats", ->
+  a={}; b={}; c={}; d={}; e={}; f={}; g={}; h={}; i={}
+  [u, [v, w..., x], y..., z] = [a, [b, c, d, e], f, g, h, i]
+  eq a, u
+  eq b, v
+  arrayEq [c,d], w
+  eq e, x
+  arrayEq [f,g,h], y
+  eq i, z
+
+test "destructuring assignment with objects", ->
+  a={}; b={}; c={}
+  obj = {a,b,c}
+  {a:x, b:y, c:z} = obj
+  eq a, x
+  eq b, y
+  eq c, z
+
+test "deep destructuring assignment with objects", ->
+  a={}; b={}; c={}; d={}
+  obj = {
+    a
+    b: {
+      'c': {
+        d: [
+          b
+          {e: c, f: d}
+        ]
+      }
+    }
+  }
+  {a: w, 'b': {c: d: [x, {'f': z, e: y}]}} = obj
+  eq a, w
+  eq b, x
+  eq c, y
+  eq d, z
+
+test "destructuring assignment with objects and splats", ->
+  a={}; b={}; c={}; d={}
+  obj = a: b: [a, b, c, d]
+  {a: b: [y, z...]} = obj
+  eq a, y
+  arrayEq [b,c,d], z
+
+test "destructuring assignment against an expression", ->
+  a={}; b={}
+  [y, z] = if true then [a, b] else [b, a]
+  eq a, y
+  eq b, z
+
+test "bracket insertion when necessary", ->
+  [a] = [0] ? [1]
+  eq a, 0
+
+# for implicit destructuring assignment in comprehensions, see the comprehension tests
+
+test "destructuring assignment with context (@) properties", ->
+  a={}; b={}; c={}; d={}; e={}
+  obj =
+    fn: () ->
+      local = [a, {b, c}, d, e]
+      [@a, {b: @b, c: @c}, @d, @e] = local
+  eq undefined, obj[key] for key in ['a','b','c','d','e']
+  obj.fn()
+  eq a, obj.a
+  eq b, obj.b
+  eq c, obj.c
+  eq d, obj.d
+  eq e, obj.e
+
+test "#1024", ->
+  eq 2 * [] = 3 + 5, 16
+
+
+# Existential Assignment
+
+test "existential assignment", ->
+  nonce = {}
+  a = false
+  a ?= nonce
+  eq false, a
+  b = undefined
+  b ?= nonce
+  eq nonce, b
+  c = null
+  c ?= nonce
+  eq nonce, c
+  d ?= nonce
+  eq nonce, d
+
+test "#1348, #1216: existential assignment compilation", ->
+  nonce = {}
+  a = nonce
+  b = (a ?= 0)
+  eq nonce, b
+  #the first ?= compiles into a statement; the second ?= compiles to a ternary expression
+  eq a ?= b ?= 1, nonce
+  
+  e ?= f ?= g ?= 1
+  eq e + g, 2
+  
+  #need to ensure the two vars are not defined, hence the strange names;
+  # broke earlier when using c ?= d ?= 1 because `d` is declared elsewhere
+  eq und1_1348 ?= und2_1348 ?= 1, 1
+  
+  if a then a ?= 2 else a = 3
+  eq a, nonce

test/booleans.coffee

@@ -0,0 +1,21 @@
+# Boolean Literals
+# ----------------
+
+# TODO: add method invocation tests: true.toString() is "true"
+
+test "#764 Booleans should be indexable", ->
+  toString = Boolean::toString
+
+  eq toString, true['toString']
+  eq toString, false['toString']
+  eq toString, yes['toString']
+  eq toString, no['toString']
+  eq toString, on['toString']
+  eq toString, off['toString']
+
+  eq toString, true.toString
+  eq toString, false.toString
+  eq toString, yes.toString
+  eq toString, no.toString
+  eq toString, on.toString
+  eq toString, off.toString

test/break.coffee

@@ -1,18 +0,0 @@
-# Break
-# -----
-
-test "break at the top level", ->
-  for i in [1,2,3]
-    result = i
-    if i == 2
-      break
-  eq 2, result
-
-test "break *not* at the top level", ->
-  someFunc = () ->
-    i = 0
-    while ++i < 3
-      result = i
-      break if i > 1
-    result
-  eq 2, someFunc()

test/classes.coffee

@@ -0,0 +1,492 @@
+# Classes
+# -------
+
+# * Class Definition
+# * Class Instantiation
+# * Inheritance and Super
+
+test "classes with a four-level inheritance chain", ->
+
+  class Base
+    func: (string) ->
+      "zero/#{string}"
+
+    @static: (string) ->
+      "static/#{string}"
+
+  class FirstChild extends Base
+    func: (string) ->
+      super('one/') + string
+
+  SecondChild = class extends FirstChild
+    func: (string) ->
+      super('two/') + string
+
+  thirdCtor = ->
+    @array = [1, 2, 3]
+
+  class ThirdChild extends SecondChild
+    constructor: -> thirdCtor.call this
+
+    # Gratuitous comment for testing.
+    func: (string) ->
+      super('three/') + string
+
+  result = (new ThirdChild).func 'four'
+
+  ok result is 'zero/one/two/three/four'
+  ok Base.static('word') is 'static/word'
+
+  FirstChild::func = (string) ->
+    super('one/').length + string
+
+  result = (new ThirdChild).func 'four'
+
+  ok result is '9two/three/four'
+
+  ok (new ThirdChild).array.join(' ') is '1 2 3'
+
+
+test "constructors with inheritance and super", ->
+
+  identity = (f) -> f
+
+  class TopClass
+    constructor: (arg) ->
+      @prop = 'top-' + arg
+
+  class SuperClass extends TopClass
+    constructor: (arg) ->
+      identity super 'super-' + arg
+
+  class SubClass extends SuperClass
+    constructor: ->
+      identity super 'sub'
+
+  ok (new SubClass).prop is 'top-super-sub'
+
+
+test "Overriding the static property new doesn't clobber Function::new", ->
+
+  class OneClass
+    @new: 'new'
+    function: 'function'
+    constructor: (name) -> @name = name
+
+  class TwoClass extends OneClass
+  delete TwoClass.new
+
+  Function.prototype.new = -> new this arguments...
+
+  ok (TwoClass.new('three')).name is 'three'
+  ok (new OneClass).function is 'function'
+  ok OneClass.new is 'new'
+
+  delete Function.prototype.new
+
+
+test "basic classes, again, but in the manual prototype style", ->
+
+  Base = ->
+  Base::func = (string) ->
+    'zero/' + string
+  Base::['func-func'] = (string) ->
+    "dynamic-#{string}"
+
+  FirstChild = ->
+  SecondChild = ->
+  ThirdChild = ->
+    @array = [1, 2, 3]
+    this
+
+  ThirdChild extends SecondChild extends FirstChild extends Base
+
+  FirstChild::func = (string) ->
+    super('one/') + string
+
+  SecondChild::func = (string) ->
+    super('two/') + string
+
+  ThirdChild::func = (string) ->
+    super('three/') + string
+
+  result = (new ThirdChild).func 'four'
+
+  ok result is 'zero/one/two/three/four'
+
+  ok (new ThirdChild)['func-func']('thing') is 'dynamic-thing'
+
+
+test "super with plain ol' functions as the original constructors", ->
+
+TopClass = (arg) ->
+  @prop = 'top-' + arg
+  this
+
+SuperClass = (arg) ->
+  super 'super-' + arg
+  this
+
+SubClass = ->
+  super 'sub'
+  this
+
+SuperClass extends TopClass
+SubClass extends SuperClass
+
+ok (new SubClass).prop is 'top-super-sub'
+
+
+test "'@' referring to the current instance, and not being coerced into a call", ->
+
+  class ClassName
+    amI: ->
+      @ instanceof ClassName
+
+  obj = new ClassName
+  ok obj.amI()
+
+
+test "super() calls in constructors of classes that are defined as object properties", ->
+
+  class Hive
+    constructor: (name) -> @name = name
+
+  class Hive.Bee extends Hive
+    constructor: (name) -> super
+
+  maya = new Hive.Bee 'Maya'
+  ok maya.name is 'Maya'
+
+
+test "classes with JS-keyword properties", ->
+
+  class Class
+    class: 'class'
+    name: -> @class
+
+  instance = new Class
+  ok instance.class is 'class'
+  ok instance.name() is 'class'
+
+
+test "Classes with methods that are pre-bound to the instance, or statically, to the class", ->
+
+  class Dog
+    constructor: (name) ->
+      @name = name
+
+    bark: =>
+      "#{@name} woofs!"
+
+    @static = =>
+      new this('Dog')
+
+  spark = new Dog('Spark')
+  fido  = new Dog('Fido')
+  fido.bark = spark.bark
+
+  ok fido.bark() is 'Spark woofs!'
+
+  obj = func: Dog.static
+
+  ok obj.func().name is 'Dog'
+
+
+test "a bound function in a bound function", ->
+
+  class Mini
+    num: 10
+    generate: =>
+      for i in [1..3]
+        =>
+          @num
+
+  m = new Mini
+  eq (func() for func in m.generate()).join(' '), '10 10 10'
+
+
+test "contructor called with varargs", ->
+
+  class Connection
+    constructor: (one, two, three) ->
+      [@one, @two, @three] = [one, two, three]
+
+    out: ->
+      "#{@one}-#{@two}-#{@three}"
+
+  list = [3, 2, 1]
+  conn = new Connection list...
+  ok conn instanceof Connection
+  ok conn.out() is '3-2-1'
+
+
+test "calling super and passing along all arguments", ->
+
+  class Parent
+    method: (args...) -> @args = args
+
+  class Child extends Parent
+    method: -> super
+
+  c = new Child
+  c.method 1, 2, 3, 4
+  ok c.args.join(' ') is '1 2 3 4'
+
+
+test "classes wrapped in decorators", ->
+
+  func = (klass) ->
+    klass::prop = 'value'
+    klass
+
+  func class Test
+    prop2: 'value2'
+
+  ok (new Test).prop  is 'value'
+  ok (new Test).prop2 is 'value2'
+
+
+test "anonymous classes", ->
+
+  obj =
+    klass: class
+      method: -> 'value'
+
+  instance = new obj.klass
+  ok instance.method() is 'value'
+
+
+test "Implicit objects as static properties", ->
+
+  class Static
+    @static =
+      one: 1
+      two: 2
+
+  ok Static.static.one is 1
+  ok Static.static.two is 2
+
+
+test "nothing classes", ->
+
+  c = class
+  ok c instanceof Function
+
+
+test "classes with value'd constructors", ->
+
+  counter = 0
+  classMaker = ->
+    inner = ++counter
+    ->
+      @value = inner
+
+  class One
+    constructor: classMaker()
+
+  class Two
+    constructor: classMaker()
+
+  eq (new One).value, 1
+  eq (new Two).value, 2
+  eq (new One).value, 1
+  eq (new Two).value, 2
+
+
+test "exectuable class bodies", ->
+
+  class A
+    if true
+      b: 'b'
+    else
+      c: 'c'
+
+  a = new A
+
+  eq a.b, 'b'
+  eq a.c, undefined
+
+
+test "mild metaprogramming", ->
+
+  class Base
+    @attr: (name) ->
+      @::[name] = (val) ->
+        if arguments.length > 0
+          @["_#{name}"] = val
+        else
+          @["_#{name}"]
+
+  class Robot extends Base
+    @attr 'power'
+    @attr 'speed'
+
+  robby = new Robot
+
+  ok robby.power() is undefined
+
+  robby.power 11
+  robby.speed Infinity
+
+  eq robby.power(), 11
+  eq robby.speed(), Infinity
+
+
+test "namespaced classes do not reserve their function name in outside scope", ->
+
+  one = {}
+  two = {}
+
+  class one.Klass
+    @label = "one"
+
+  class two.Klass
+    @label = "two"
+
+  eq typeof Klass, 'undefined'
+  eq one.Klass.label, 'one'
+  eq two.Klass.label, 'two'
+
+
+test "nested classes", ->
+
+  class Outer
+    constructor: ->
+      @label = 'outer'
+
+    class @Inner
+      constructor: ->
+        @label = 'inner'
+
+  eq (new Outer).label, 'outer'
+  eq (new Outer.Inner).label, 'inner'
+
+
+test "variables in constructor bodies are correctly scoped", ->
+
+  class A
+    x = 1
+    constructor: ->
+      x = 10
+      y = 20
+    y = 2
+    captured: ->
+      {x, y}
+
+  a = new A
+  eq a.captured().x, 10
+  eq a.captured().y, 2
+
+
+test "Issue #924: Static methods in nested classes", ->
+
+  class A
+    @B: class
+      @c = -> 5
+
+  eq A.B.c(), 5
+
+
+test "`class extends this`", ->
+
+  class A
+    func: -> 'A'
+
+  B = null
+  makeClass = ->
+    B = class extends this
+      func: -> super + ' B'
+
+  makeClass.call A
+
+  eq (new B()).func(), 'A B'
+
+
+test "ensure that constructors invoked with splats return a new object", ->
+
+  args = [1, 2, 3]
+  Type = (@args) ->
+  type = new Type args
+
+  ok type and type instanceof Type
+  ok type.args and type.args instanceof Array
+  ok v is args[i] for v, i in type.args
+
+  Type1 = (@a, @b, @c) ->
+  type1 = new Type1 args...
+
+  ok type1 instanceof   Type1
+  eq type1.constructor, Type1
+  ok type1.a is args[0] and type1.b is args[1] and type1.c is args[2]
+
+  # Ensure that constructors invoked with splats cache the function.
+  called = 0
+  get = -> if called++ then false else class Type
+  new get() args...
+
+test "`new` shouldn't add extra parens", ->
+
+  ok new Date().constructor is Date
+
+
+test "`new` works against bare function", ->
+
+  eq Date, new ->
+    eq this, new => this
+    Date
+
+
+test "#1182: a subclass should be able to set its constructor to an external function", ->
+  ctor = ->
+    @val = 1
+  class A
+  class B extends A
+    constructor: ctor
+  eq (new B).val, 1
+
+test "#1182: external constructors continued", ->
+  ctor = ->
+  class A
+  class B extends A
+    method: ->
+    constructor: ctor
+  ok B::method
+
+test "#1313: misplaced __extends", ->
+  nonce = {}
+  class A
+  class B extends A
+    prop: nonce
+    constructor: ->
+  eq nonce, B::prop
+
+test "#1182: execution order needs to be considered as well", ->
+  counter = 0
+  makeFn = (n) -> eq n, ++counter; ->
+  class B extends (makeFn 1)
+    @B: makeFn 2
+    constructor: makeFn 3
+
+test "#1182: external constructors with bound functions", ->
+  fn = ->
+    {one: 1}
+  class B
+  class A
+    constructor: fn
+    method: => this instanceof A
+  ok (new A).method.call(new B)
+
+test "#1372: bound class methods with reserved names", ->
+  class C
+    delete: =>
+  ok C::delete
+
+test "#1380: `super` with reserved names", ->
+  class C
+    do: -> super
+  ok C::do
+
+  class B
+    0: -> super
+  ok B::[0]

test/comments.coffee

@@ -1,6 +1,9 @@
 # Comments
 # --------
 
+# * Single-Line Comments
+# * Block Comments
+
 # Note: awkward spacing seen in some tests is likely intentional.
 
 test "comments in objects", ->
@@ -107,7 +110,7 @@ test "spaced comments with conditional statements", ->
   eq nonce, result
 
 
-#### Block Comments
+# Block Comments
 
 ###
   This is a here-comment.

test/compilation.coffee

@@ -0,0 +1,61 @@
+# Compilation
+# -----------
+
+# helper to assert that a string should fail compilation
+cantCompile = (code) ->
+  throws -> CoffeeScript.compile code
+
+
+test "ensure that carriage returns don't break compilation on Windows", ->
+  doesNotThrow -> CoffeeScript.compile 'one\r\ntwo', bare: on
+
+test "--bare", ->
+  eq -1, CoffeeScript.compile('x = y', bare: on).indexOf 'function'
+  ok 'passed' is CoffeeScript.eval '"passed"', bare: on, filename: 'test'
+
+test "multiple generated references", ->
+  a = {b: []}
+  a.b[true] = -> this == a.b
+  c = 0
+  d = []
+  ok a.b[0<++c<2] d...
+
+test "splat on a line by itself is invalid", ->
+  cantCompile "x 'a'\n...\n"
+
+test "Issue 750", ->
+
+  cantCompile 'f(->'
+
+  cantCompile 'a = (break)'
+
+  cantCompile 'a = (return 5 for item in list)'
+
+  cantCompile 'a = (return 5 while condition)'
+
+  cantCompile 'a = for x in y\n  return 5'
+
+test "Issue #986: Unicode identifiers", ->
+  λ = 5
+  eq λ, 5
+
+test "don't accidentally stringify keywords", ->
+  ok (-> this == 'this')() is false
+
+test "#1026", ->
+  cantCompile '''
+    if a
+      b
+    else
+      c
+    else
+      d
+  '''
+
+test "#1050", ->
+  cantCompile "### */ ###"
+
+test "#1106: __proto__ compilation", ->
+  object = eq
+  @["__proto__"] = true
+  ok __proto__

test/comprehensions.coffee

@@ -0,0 +1,430 @@
+# Comprehensions
+# --------------
+
+# * Array Comprehensions
+# * Range Comprehensions
+# * Object Comprehensions
+# * Implicit Destructuring Assignment
+# * Comprehensions with Nonstandard Step
+
+# TODO: refactor comprehension tests
+
+test "Basic array comprehensions.", ->
+
+  nums    = (n * n for n in [1, 2, 3] when n & 1)
+  results = (n * 2 for n in nums)
+
+  ok results.join(',') is '2,18'
+
+
+test "Basic object comprehensions.", ->
+
+  obj   = {one: 1, two: 2, three: 3}
+  names = (prop + '!' for prop of obj)
+  odds  = (prop + '!' for prop, value of obj when value & 1)
+
+  ok names.join(' ') is "one! two! three!"
+  ok odds.join(' ')  is "one! three!"
+
+
+test "Basic range comprehensions.", ->
+
+  nums = (i * 3 for i in [1..3])
+
+  negs = (x for x in [-20..-5*2])
+  negs = negs[0..2]
+
+  result = nums.concat(negs).join(', ')
+
+  ok result is '3, 6, 9, -20, -19, -18'
+
+
+test "With range comprehensions, you can loop in steps.", ->
+
+  results = (x for x in [0...15] by 5)
+  ok results.join(' ') is '0 5 10'
+
+  results = (x for x in [0..100] by 10)
+  ok results.join(' ') is '0 10 20 30 40 50 60 70 80 90 100'
+
+
+test "And can loop downwards, with a negative step.", ->
+
+  results = (x for x in [5..1])
+
+  ok results.join(' ') is '5 4 3 2 1'
+  ok results.join(' ') is [(10-5)..(-2+3)].join(' ')
+
+  results = (x for x in [10..1])
+  ok results.join(' ') is [10..1].join(' ')
+
+  results = (x for x in [10...0] by -2)
+  ok results.join(' ') is [10, 8, 6, 4, 2].join(' ')
+
+
+test "Range comprehension gymnastics.", ->
+
+  eq "#{i for i in [5..1]}", '5,4,3,2,1'
+  eq "#{i for i in [5..-5] by -5}", '5,0,-5'
+
+  a = 6
+  b = 0
+  c = -2
+
+  eq "#{i for i in [a..b]}", '6,5,4,3,2,1,0'
+  eq "#{i for i in [a..b] by c}", '6,4,2,0'
+
+
+test "Multiline array comprehension with filter.", ->
+
+  evens = for num in [1, 2, 3, 4, 5, 6] when not (num & 1)
+             num *= -1
+             num -= 2
+             num * -1
+  eq evens + '', '4,6,8'
+
+
+  test "The in operator still works, standalone.", ->
+
+    ok 2 of evens
+
+
+test "all isn't reserved.", ->
+
+  all = 1
+
+
+test "Ensure that the closure wrapper preserves local variables.", ->
+
+  obj = {}
+
+  for method in ['one', 'two', 'three'] then do (method) ->
+    obj[method] = ->
+      "I'm " + method
+
+  ok obj.one()   is "I'm one"
+  ok obj.two()   is "I'm two"
+  ok obj.three() is "I'm three"
+
+
+test "Index values at the end of a loop.", ->
+
+  i = 0
+  for i in [1..3]
+    -> 'func'
+    break if false
+  ok i is 4
+
+
+test "Ensure that local variables are closed over for range comprehensions.", ->
+
+  funcs = for i in [1..3]
+    do (i) ->
+      -> -i
+
+  eq (func() for func in funcs).join(' '), '-1 -2 -3'
+  ok i is 4
+
+
+test "Even when referenced in the filter.", ->
+
+  list = ['one', 'two', 'three']
+
+  methods = for num, i in list when num isnt 'two' and i isnt 1
+    do (num, i) ->
+      -> num + ' ' + i
+
+  ok methods.length is 2
+  ok methods[0]() is 'one 0'
+  ok methods[1]() is 'three 2'
+
+
+test "Even a convoluted one.", ->
+
+  funcs = []
+
+  for i in [1..3]
+    do (i) ->
+      x = i * 2
+      ((z)->
+        funcs.push -> z + ' ' + i
+      )(x)
+
+  ok (func() for func in funcs).join(', ') is '2 1, 4 2, 6 3'
+
+  funcs = []
+
+  results = for i in [1..3]
+    do (i) ->
+      z = (x * 3 for x in [1..i])
+      ((a, b, c) -> [a, b, c].join(' ')).apply this, z
+
+  ok results.join(', ') is '3  , 3 6 , 3 6 9'
+
+
+test "Naked ranges are expanded into arrays.", ->
+
+  array = [0..10]
+  ok(num % 2 is 0 for num in array by 2)
+
+
+test "Nested shared scopes.", ->
+
+  foo = ->
+    for i in [0..7]
+      do (i) ->
+        for j in [0..7]
+          do (j) ->
+            -> i + j
+
+  eq foo()[3][4](), 7
+
+
+test "Scoped loop pattern matching.", ->
+
+  a = [[0], [1]]
+  funcs = []
+
+  for [v] in a
+    do (v) ->
+      funcs.push -> v
+
+  eq funcs[0](), 0
+  eq funcs[1](), 1
+
+
+test "Nested comprehensions.", ->
+
+  multiLiner =
+    for x in [3..5]
+      for y in [3..5]
+        [x, y]
+
+  singleLiner =
+    (([x, y] for y in [3..5]) for x in [3..5])
+
+  ok multiLiner.length is singleLiner.length
+  ok 5 is multiLiner[2][2][1]
+  ok 5 is singleLiner[2][2][1]
+
+
+test "Comprehensions within parentheses.", ->
+
+  result = null
+  store = (obj) -> result = obj
+  store (x * 2 for x in [3, 2, 1])
+
+  ok result.join(' ') is '6 4 2'
+
+
+test "Closure-wrapped comprehensions that refer to the 'arguments' object.", ->
+
+  expr = ->
+    result = (item * item for item in arguments)
+
+  ok expr(2, 4, 8).join(' ') is '4 16 64'
+
+
+test "Fast object comprehensions over all properties, including prototypal ones.", ->
+
+  class Cat
+    constructor: -> @name = 'Whiskers'
+    breed: 'tabby'
+    hair:  'cream'
+
+  whiskers = new Cat
+  own = (value for own key, value of whiskers)
+  all = (value for key, value of whiskers)
+
+  ok own.join(' ') is 'Whiskers'
+  ok all.sort().join(' ') is 'Whiskers cream tabby'
+
+
+test "Optimized range comprehensions.", ->
+
+  exxes = ('x' for [0...10])
+  ok exxes.join(' ') is 'x x x x x x x x x x'
+
+
+test "Comprehensions safely redeclare parameters if they're not present in closest scope.", ->
+
+  rule = (x) -> x
+
+  learn = ->
+    rule for rule in [1, 2, 3]
+
+  ok learn().join(' ') is '1 2 3'
+
+  ok rule(101) is 101
+
+  f = -> [-> ok no, 'should cache source']
+  ok yes for k of [f] = f()
+
+
+test "Lenient on pure statements not trying to reach out of the closure", ->
+
+  val = for i in [1]
+    for j in [] then break
+    i
+  ok val[0] is i
+
+
+test "Comprehensions only wrap their last line in a closure, allowing other lines
+  to have pure expressions in them.", ->
+
+  func = -> for i in [1]
+    break if i is 2
+    j for j in [1]
+
+  ok func()[0][0] is 1
+
+  i = 6
+  odds = while i--
+    continue unless i & 1
+    i
+
+  ok odds.join(', ') is '5, 3, 1'
+
+
+test "Issue #897: Ensure that plucked function variables aren't leaked.", ->
+
+  facets = {}
+  list = ['one', 'two']
+
+  (->
+    for entity in list
+      facets[entity] = -> entity
+  )()
+
+  eq typeof entity, 'undefined'
+  eq facets['two'](), 'two'
+
+
+test "Issue #905. Soaks as the for loop subject.", ->
+
+  a = {b: {c: [1, 2, 3]}}
+  for d in a.b?.c
+    e = d
+
+  eq e, 3
+
+
+test "Issue #948. Capturing loop variables.", ->
+
+  funcs = []
+  list  = ->
+    [1, 2, 3]
+
+  for y in list()
+    do (y) ->
+      z = y
+      funcs.push -> "y is #{y} and z is #{z}"
+
+  eq funcs[1](), "y is 2 and z is 2"
+
+
+test "Cancel the comprehension if there's a jump inside the loop.", ->
+
+  result = try
+    for i in [0...10]
+      continue if i < 5
+    i
+
+  eq result, 10
+
+
+test "Comprehensions over break.", ->
+
+  arrayEq (break for [1..10]), []
+
+
+test "Comprehensions over continue.", ->
+
+  arrayEq (continue for [1..10]), []
+
+
+test "Comprehensions over function literals.", ->
+
+  a = 0
+  for f in [-> a = 1]
+    do (f) ->
+      do f
+
+  eq a, 1
+
+
+test "Comprehensions that mention arguments.", ->
+
+  list = [arguments: 10]
+  args = for f in list
+    do (f) ->
+      f.arguments
+  eq args[0], 10
+
+
+test "expression conversion under explicit returns", ->
+  nonce = {}
+  fn = ->
+    return (nonce for x in [1,2,3])
+  arrayEq [nonce,nonce,nonce], fn()
+  fn = ->
+    return [nonce for x in [1,2,3]][0]
+  arrayEq [nonce,nonce,nonce], fn()
+  fn = ->
+    return [(nonce for x in [1..3])][0]
+  arrayEq [nonce,nonce,nonce], fn()
+
+
+test "implicit destructuring assignment in object of objects", ->
+  a={}; b={}; c={}
+  obj = {
+    a: { d: a },
+    b: { d: b }
+    c: { d: c }
+  }
+  result = ([y,z] for y, { d: z } of obj)
+  arrayEq [['a',a],['b',b],['c',c]], result
+
+
+test "implicit destructuring assignment in array of objects", ->
+  a={}; b={}; c={}; d={}; e={}; f={}
+  arr = [
+    { a: a, b: { c: b } },
+    { a: c, b: { c: d } },
+    { a: e, b: { c: f } }
+  ]
+  result = ([y,z] for { a: y, b: { c: z } } in arr)
+  arrayEq [[a,b],[c,d],[e,f]], result
+
+
+test "implicit destructuring assignment in array of arrays", ->
+  a={}; b={}; c={}; d={}; e={}; f={}
+  arr = [[a, [b]], [c, [d]], [e, [f]]]
+  result = ([y,z] for [y, [z]] in arr)
+  arrayEq [[a,b],[c,d],[e,f]], result
+
+test "issue #1124: don't assign a variable in two scopes", ->
+  lista = [1, 2, 3, 4, 5]
+  listb = (_i + 1 for _i in lista)
+  arrayEq [2, 3, 4, 5, 6], listb
+
+test "#1326: `by` value is uncached", ->
+  a = [0,1,2]
+  fi = gi = hi = 0
+  f = -> ++fi
+  g = -> ++gi
+  h = -> ++hi
+
+  forCompile = []
+  rangeCompileSimple = []
+
+  #exercises For.compile
+  for v,i in a by f() then forCompile.push i
+
+  #exercises Range.compileSimple
+  rangeCompileSimple = (i for i in [0..2] by g())
+
+  arrayEq a, forCompile
+  arrayEq a, rangeCompileSimple
+  #exercises Range.compile
+  eq "#{i for i in [0..2] by h()}", '0,1,2'

test/conditionals.coffee

@@ -1,181 +0,0 @@
-# Conditionals
-# ------------
-
-# shared identity function
-id = (_) -> if arguments.length is 1 then _ else Array::slice.call(arguments)
-
-#### Basic Conditionals
-
-test "basic conditionals", ->
-  if false
-    ok false
-  else if false
-    ok false
-  else
-    ok true
-
-  if true
-    ok true
-  else if true
-    ok false
-  else
-    ok true
-
-  unless true
-    ok false
-  else unless true
-    ok false
-  else
-    ok true
-
-  unless false
-    ok true
-  else unless false
-    ok false
-  else
-    ok true
-
-test "single-line conditional", ->
-  if false then ok false else ok true
-  unless false then ok true else ok false
-
-test "nested conditionals", ->
-  nonce = {}
-  eq nonce, (if true
-    unless false
-      if false then false else
-        if true
-          nonce)
-
-test "nested single-line conditionals", ->
-  nonce = {}
-
-  a = if false then undefined else b = if 0 then undefined else nonce
-  eq nonce, a
-  eq nonce, b
-
-  c = if false then undefined else (if 0 then undefined else nonce)
-  eq nonce, c
-
-  d = if true then id(if false then undefined else nonce)
-  eq nonce, d
-
-test "empty conditional bodies", ->
-  eq undefined, (if false
-  else if false
-  else)
-
-test "conditional bodies containing only comments", ->
-  eq undefined, (if true
-    ###
-    block comment
-    ###
-  else
-    # comment
-  )
-
-  eq undefined, (if false
-    # comment
-  else if true
-    ###
-    block comment
-    ###
-  else)
-
-test "return value of if-else is from the proper body", ->
-  nonce = {}
-  eq nonce, if false then undefined else nonce
-
-test "return value of unless-else is from the proper body", ->
-  nonce = {}
-  eq nonce, unless true then undefined else nonce
-
-
-#### Interactions With Functions
-
-test "single-line function definition with single-line conditional", ->
-  fn = -> if 1 < 0.5 then 1 else -1
-  ok fn() is -1
-
-test "function resturns conditional value with no `else`", ->
-  fn = ->
-    return if false then true
-  eq undefined, fn()
-
-test "function returns a conditional value", ->
-  a = {}
-  fnA = ->
-    return if false then undefined else a
-  eq a, fnA()
-
-  b = {}
-  fnB = ->
-    return unless false then b else undefined
-  eq b, fnB()
-
-test "passing a conditional value to a function", ->
-  nonce = {}
-  eq nonce, id if false then undefined else nonce
-
-test "unmatched `then` should catch implicit calls", ->
-  a = 0
-  trueFn = -> true
-  if trueFn undefined then a += 1
-  eq 1, a
-
-
-#### if-to-ternary
-
-test "if-to-ternary with instanceof requires parentheses", ->
-  nonce = {}
-  eq nonce, (if {} instanceof Object
-    nonce
-  else
-    undefined)
-
-test "if-to-ternary as part of a larger operation requires parentheses", ->
-  ok 2, 1 + if false then 0 else 1
-
-
-#### Odd Formatting
-
-test "if-else indented within an assignment", ->
-  nonce = {}
-  result =
-    if false
-      undefined
-    else
-      nonce
-  eq nonce, result
-
-test "suppressed indentation via assignment", ->
-  nonce = {}
-  result =
-    if      false then undefined
-    else if no    then undefined
-    else if 0     then undefined
-    else if 1 < 0 then undefined
-    else               id(
-         if false then undefined
-         else          nonce
-    )
-  eq nonce, result
-
-test "tight formatting with leading `then`", ->
-  nonce = {}
-  eq nonce,
-  if true
-  then nonce
-  else undefined
-
-test "#738", ->
-  nonce = {}
-  fn = if true then -> nonce
-  eq nonce, fn()
-
-test "#748: trailing reserved identifiers", ->
-  nonce = {}
-  obj = delete: true
-  result = if obj.delete
-    nonce
-  eq nonce, result

test/control_flow.coffee

@@ -0,0 +1,420 @@
+# Control Flow
+# ------------
+
+# * Conditionals
+# * Loops
+#   * For
+#   * While
+#   * Until
+#   * Loop
+# * Switch
+
+# TODO: make sure postfix forms and expression coercion are properly tested
+
+# shared identity function
+id = (_) -> if arguments.length is 1 then _ else Array::slice.call(arguments)
+
+# Conditionals
+
+test "basic conditionals", ->
+  if false
+    ok false
+  else if false
+    ok false
+  else
+    ok true
+
+  if true
+    ok true
+  else if true
+    ok false
+  else
+    ok true
+
+  unless true
+    ok false
+  else unless true
+    ok false
+  else
+    ok true
+
+  unless false
+    ok true
+  else unless false
+    ok false
+  else
+    ok true
+
+test "single-line conditional", ->
+  if false then ok false else ok true
+  unless false then ok true else ok false
+
+test "nested conditionals", ->
+  nonce = {}
+  eq nonce, (if true
+    unless false
+      if false then false else
+        if true
+          nonce)
+
+test "nested single-line conditionals", ->
+  nonce = {}
+
+  a = if false then undefined else b = if 0 then undefined else nonce
+  eq nonce, a
+  eq nonce, b
+
+  c = if false then undefined else (if 0 then undefined else nonce)
+  eq nonce, c
+
+  d = if true then id(if false then undefined else nonce)
+  eq nonce, d
+
+test "empty conditional bodies", ->
+  eq undefined, (if false
+  else if false
+  else)
+
+test "conditional bodies containing only comments", ->
+  eq undefined, (if true
+    ###
+    block comment
+    ###
+  else
+    # comment
+  )
+
+  eq undefined, (if false
+    # comment
+  else if true
+    ###
+    block comment
+    ###
+  else)
+
+test "return value of if-else is from the proper body", ->
+  nonce = {}
+  eq nonce, if false then undefined else nonce
+
+test "return value of unless-else is from the proper body", ->
+  nonce = {}
+  eq nonce, unless true then undefined else nonce
+
+test "assign inside the condition of a conditional statement", ->
+  nonce = {}
+  if a = nonce then 1
+  eq nonce, a
+  1 if b = nonce
+  eq nonce, b
+
+
+# Interactions With Functions
+
+test "single-line function definition with single-line conditional", ->
+  fn = -> if 1 < 0.5 then 1 else -1
+  ok fn() is -1
+
+test "function resturns conditional value with no `else`", ->
+  fn = ->
+    return if false then true
+  eq undefined, fn()
+
+test "function returns a conditional value", ->
+  a = {}
+  fnA = ->
+    return if false then undefined else a
+  eq a, fnA()
+
+  b = {}
+  fnB = ->
+    return unless false then b else undefined
+  eq b, fnB()
+
+test "passing a conditional value to a function", ->
+  nonce = {}
+  eq nonce, id if false then undefined else nonce
+
+test "unmatched `then` should catch implicit calls", ->
+  a = 0
+  trueFn = -> true
+  if trueFn undefined then a++
+  eq 1, a
+
+
+# if-to-ternary
+
+test "if-to-ternary with instanceof requires parentheses", ->
+  nonce = {}
+  eq nonce, (if {} instanceof Object
+    nonce
+  else
+    undefined)
+
+test "if-to-ternary as part of a larger operation requires parentheses", ->
+  ok 2, 1 + if false then 0 else 1
+
+
+# Odd Formatting
+
+test "if-else indented within an assignment", ->
+  nonce = {}
+  result =
+    if false
+      undefined
+    else
+      nonce
+  eq nonce, result
+
+test "suppressed indentation via assignment", ->
+  nonce = {}
+  result =
+    if      false then undefined
+    else if no    then undefined
+    else if 0     then undefined
+    else if 1 < 0 then undefined
+    else               id(
+         if false then undefined
+         else          nonce
+    )
+  eq nonce, result
+
+test "tight formatting with leading `then`", ->
+  nonce = {}
+  eq nonce,
+  if true
+  then nonce
+  else undefined
+
+test "#738", ->
+  nonce = {}
+  fn = if true then -> nonce
+  eq nonce, fn()
+
+test "#748: trailing reserved identifiers", ->
+  nonce = {}
+  obj = delete: true
+  result = if obj.delete
+    nonce
+  eq nonce, result
+
+
+test "basic `while` loops", ->
+
+  i = 5
+  list = while i -= 1
+    i * 2
+  ok list.join(' ') is "8 6 4 2"
+
+  i = 5
+  list = (i * 3 while i -= 1)
+  ok list.join(' ') is "12 9 6 3"
+
+  i = 5
+  func   = (num) -> i -= num
+  assert = -> ok i < 5 > 0
+  results = while func 1
+    assert()
+    i
+  ok results.join(' ') is '4 3 2 1'
+
+  i = 10
+  results = while i -= 1 when i % 2 is 0
+    i * 2
+  ok results.join(' ') is '16 12 8 4'
+
+
+test "Issue 759: `if` within `while` condition", ->
+
+  2 while if 1 then 0
+
+
+test "assignment inside the condition of a `while` loop", ->
+
+  nonce = {}
+  count = 1
+  a = nonce while count--
+  eq nonce, a
+  count = 1
+  while count--
+    b = nonce
+  eq nonce, b
+
+
+test "While over break.", ->
+
+  i = 0
+  result = while i < 10
+    i++
+    break
+  arrayEq result, []
+
+
+test "While over continue.", ->
+
+  i = 0
+  result = while i < 10
+    i++
+    continue
+  arrayEq result, []
+
+
+test "Basic `until`", ->
+
+  value = false
+  i = 0
+  results = until value
+    value = true if i is 5
+    i++
+  ok i is 6
+
+
+test "Basic `loop`", ->
+
+  i = 5
+  list = []
+  loop
+    i -= 1
+    break if i is 0
+    list.push i * 2
+  ok list.join(' ') is '8 6 4 2'
+
+
+test "break at the top level", ->
+  for i in [1,2,3]
+    result = i
+    if i == 2
+      break
+  eq 2, result
+
+test "break *not* at the top level", ->
+  someFunc = ->
+    i = 0
+    while ++i < 3
+      result = i
+      break if i > 1
+    result
+  eq 2, someFunc()
+
+
+test "basic `switch`", ->
+
+  num = 10
+  result = switch num
+    when 5 then false
+    when 'a'
+      true
+      true
+      false
+    when 10 then true
+
+
+    # Mid-switch comment with whitespace
+    # and multi line
+    when 11 then false
+    else false
+
+  ok result
+
+
+  func = (num) ->
+    switch num
+      when 2, 4, 6
+        true
+      when 1, 3, 5
+        false
+
+  ok func(2)
+  ok func(6)
+  ok !func(3)
+  eq func(8), undefined
+
+
+test "Ensure that trailing switch elses don't get rewritten.", ->
+
+  result = false
+  switch "word"
+    when "one thing"
+      doSomething()
+    else
+      result = true unless false
+
+  ok result
+
+  result = false
+  switch "word"
+    when "one thing"
+      doSomething()
+    when "other thing"
+      doSomething()
+    else
+      result = true unless false
+
+  ok result
+
+
+test "Should be able to handle switches sans-condition.", ->
+
+  result = switch
+    when null                     then 0
+    when !1                       then 1
+    when '' not of {''}           then 2
+    when [] not instanceof Array  then 3
+    when true is false            then 4
+    when 'x' < 'y' > 'z'          then 5
+    when 'a' in ['b', 'c']        then 6
+    when 'd' in (['e', 'f'])      then 7
+    else ok
+
+  eq result, ok
+
+
+test "Should be able to use `@properties` within the switch clause.", ->
+
+  obj = {
+    num: 101
+    func: ->
+      switch @num
+        when 101 then '101!'
+        else 'other'
+  }
+
+  ok obj.func() is '101!'
+
+
+test "Should be able to use `@properties` within the switch cases.", ->
+
+  obj = {
+    num: 101
+    func: (yesOrNo) ->
+      result = switch yesOrNo
+        when yes then @num
+        else 'other'
+      result
+  }
+
+  ok obj.func(yes) is 101
+
+
+test "Switch with break as the return value of a loop.", ->
+
+  i = 10
+  results = while i > 0
+    i--
+    switch i % 2
+      when 1 then i
+      when 0 then break
+
+  eq results.join(', '), '9, , 7, , 5, , 3, , 1, '
+
+
+test "Issue #997. Switch doesn't fallthrough.", ->
+
+  val = 1
+  switch true
+    when true
+      if false
+        return 5
+    else
+      val = 2
+
+  eq val, 1

test/exception_handling.coffee

@@ -1,17 +1,17 @@
-# Exceptions
-# ----------
+# Exception Handling
+# ------------------
 
 # shared nonce
 nonce = {}
 
 
-#### Throw
+# Throw
 
 test "basic exception throwing", ->
   throws (-> throw 'error'), 'error'
 
 
-#### Empty Try/Catch/Finally
+# Empty Try/Catch/Finally
 
 test "try can exist alone", ->
   try
@@ -43,7 +43,7 @@ test "single-line try/catch/finally with empty try, empty catch, empty finally",
   try catch err then finally
 
 
-#### Try/Catch/Finally as an Expression
+# Try/Catch/Finally as an Expression
 
 test "return the result of try when no exception is thrown", ->
   result = try
@@ -81,7 +81,7 @@ test "optional catch", ->
   eq nonce, fn()
 
 
-#### Try/Catch/Finally Interaction With Other Constructs
+# Try/Catch/Finally Interaction With Other Constructs
 
 test "try/catch with empty catch as last statement in a function body", ->
   fn = ->

test/formatting.coffee

@@ -0,0 +1,123 @@
+# Formatting
+# ----------
+
+# TODO: maybe this file should be split up into their respective sections:
+#   operators -> operators
+#   array literals -> array literals
+#   string literals -> string literals
+#   function invocations -> function invocations
+
+# * Line Continuation
+#   * Property Accesss
+#   * Operators
+#   * Array Literals
+#   * Function Invocations
+#   * String Literals
+
+doesNotThrow -> CoffeeScript.compile "a = then b"
+
+test "multiple semicolon-separated statements in parentheticals", ->
+  nonce = {}
+  eq nonce, (1; 2; nonce)
+  eq nonce, (-> return (1; 2; nonce))()
+
+# Line Continuation
+
+# Property Access
+
+test "chained accesses split on period/newline, backwards and forwards", ->
+  str = 'abc'
+  result = str.
+    split('').
+    reverse().
+    reverse().
+    reverse()
+  arrayEq ['c','b','a'], result
+  arrayEq ['c','b','a'], str.
+    split('').
+    reverse().
+    reverse().
+    reverse()
+  result = str
+    .split('')
+    .reverse()
+    .reverse()
+    .reverse()
+  arrayEq ['c','b','a'], result
+  arrayEq ['c','b','a'], str
+    .split('')
+    .reverse()
+    .reverse()
+    .reverse()
+  arrayEq ['c','b','a'], str.
+    split('')
+    .reverse().
+    reverse()
+    .reverse()
+
+# Operators
+
+test "newline suppression for operators", ->
+  six =
+    1 +
+    2 +
+    3
+  eq 6, six
+
+test "`?.` and `::` should continue lines", ->
+  ok not Date
+  ::
+  ?.foo
+  #eq Object::toString, Date?.
+  #prototype
+  #::
+  #?.foo
+
+doesNotThrow -> CoffeeScript.compile """
+  oh. yes
+  oh?. true
+  oh:: return
+  """
+
+doesNotThrow -> CoffeeScript.compile """
+  a?[b..]
+  a?[...b]
+  a?[b..c]
+  """
+
+# Array Literals
+
+test "indented array literals don't trigger whitespace rewriting", ->
+  getArgs = -> arguments
+  result = getArgs(
+    [[[[[],
+                  []],
+                [[]]]],
+      []])
+  eq 1, result.length
+
+# Function Invocations
+
+doesNotThrow -> CoffeeScript.compile """
+  obj = then fn 1,
+    1: 1
+    a:
+      b: ->
+        fn c,
+          d: e
+    f: 1
+  """
+
+# String Literals
+
+test "indented heredoc", ->
+  result = ((_) -> _)(
+                """
+                abc
+                """)
+  eq "abc", result
+
+# Nested blocks caused by paren unwrapping
+test "#1492: Nested blocks don't cause double semicolons", ->
+  js = CoffeeScript.compile '(0;0)'
+  eq -1, js.indexOf ';;'

test/function_invocation.coffee

@@ -0,0 +1,508 @@
+# Function Invocation
+# -------------------
+
+# * Function Invocation
+# * Splats in Function Invocations
+# * Implicit Returns
+# * Explicit Returns
+
+# shared identity function
+id = (_) -> if arguments.length is 1 then _ else [arguments...]
+
+
+test "basic argument passing", ->
+
+  a = {}
+  b = {}
+  c = {}
+  eq 1, (id 1)
+  eq 2, (id 1, 2)[1]
+  eq a, (id a)
+  eq c, (id a, b, c)[2]
+
+
+test "passing arguments on separate lines", ->
+
+  a = {}
+  b = {}
+  c = {}
+  ok(id(
+    a
+    b
+    c
+  )[1] is b)
+  eq(0, id(
+    0
+    10
+  )[0])
+  eq(a,id(
+    a
+  ))
+  eq b,
+  (id b)
+
+
+test "optional parens can be used in a nested fashion", ->
+
+  call = (func) -> func()
+  add = (a,b) -> a + b
+  result = call ->
+    inner = call ->
+      add 5, 5
+  ok result is 10
+
+
+test "hanging commas and semicolons in argument list", ->
+
+  fn = () -> arguments.length
+  eq 2, fn(0,1,)
+  eq 3, fn 0, 1,
+  2
+  eq 2, fn(0, 1;)
+  # TODO: this test fails (the string compiles), but should it?
+  #throws -> CoffeeScript.compile "fn(0,1,;)"
+  throws -> CoffeeScript.compile "fn(0,1,;;)"
+  throws -> CoffeeScript.compile "fn(0, 1;,)"
+  throws -> CoffeeScript.compile "fn(,0)"
+  throws -> CoffeeScript.compile "fn(;0)"
+
+
+test "function invocation", ->
+
+  func = ->
+    return if true
+  eq undefined, func()
+
+  result = ("hello".slice) 3
+  ok result is 'lo'
+
+
+test "And even with strange things like this:", ->
+
+  funcs  = [((x) -> x), ((x) -> x * x)]
+  result = funcs[1] 5
+  ok result is 25
+
+
+test "More fun with optional parens.", ->
+
+  fn = (arg) -> arg
+  ok fn(fn {prop: 101}).prop is 101
+
+  okFunc = (f) -> ok(f())
+  okFunc -> true
+
+
+test "chained function calls", ->
+  nonce = {}
+  identityWrap = (x) ->
+    -> x
+  eq nonce, identityWrap(identityWrap(nonce))()()
+  eq nonce, (identityWrap identityWrap nonce)()()
+
+
+test "Multi-blocks with optional parens.", ->
+
+  fn = (arg) -> arg
+  result = fn( ->
+    fn ->
+      "Wrapped"
+  )
+  ok result()() is 'Wrapped'
+
+
+test "method calls", ->
+
+  fnId = (fn) -> -> fn.apply this, arguments
+  math = {
+    add: (a, b) -> a + b
+    anonymousAdd: (a, b) -> a + b
+    fastAdd: fnId (a, b) -> a + b
+  }
+  ok math.add(5, 5) is 10
+  ok math.anonymousAdd(10, 10) is 20
+  ok math.fastAdd(20, 20) is 40
+
+
+test "Ensure that functions can have a trailing comma in their argument list", ->
+
+  mult = (x, mids..., y) ->
+    x *= n for n in mids
+    x *= y
+  ok mult(1, 2,) is 2
+  ok mult(1, 2, 3,) is 6
+  ok mult(10, (i for i in [1..6])...) is 7200
+
+
+test "`@` and `this` should both be able to invoke a method", ->
+  nonce = {}
+  fn          = (arg) -> eq nonce, arg
+  fn.withAt   = -> @ nonce
+  fn.withThis = -> this nonce
+  fn.withAt()
+  fn.withThis()
+
+
+test "Trying an implicit object call with a trailing function.", ->
+
+  a = null
+  meth = (arg, obj, func) -> a = [obj.a, arg, func()].join ' '
+  meth 'apple', b: 1, a: 13, ->
+    'orange'
+  ok a is '13 apple orange'
+
+
+test "Ensure that empty functions don't return mistaken values.", ->
+
+  obj =
+    func: (@param, @rest...) ->
+  ok obj.func(101, 102, 103, 104) is undefined
+  ok obj.param is 101
+  ok obj.rest.join(' ') is '102 103 104'
+
+
+test "Passing multiple functions without paren-wrapping is legal, and should compile.", ->
+
+  sum = (one, two) -> one() + two()
+  result = sum ->
+    7 + 9
+  , ->
+    1 + 3
+  ok result is 20
+
+
+test "Implicit call with a trailing if statement as a param.", ->
+
+  func = -> arguments[1]
+  result = func 'one', if false then 100 else 13
+  ok result is 13
+
+
+test "Test more function passing:", ->
+
+  sum = (one, two) -> one() + two()
+
+  result = sum( ->
+    1 + 2
+  , ->
+    2 + 1
+  )
+  ok result is 6
+
+  sum = (a, b) -> a + b
+  result = sum(1
+  , 2)
+  ok result is 3
+
+
+test "Chained blocks, with proper indentation levels:", ->
+
+  counter =
+    results: []
+    tick: (func) ->
+      @results.push func()
+      this
+  counter
+    .tick ->
+      3
+    .tick ->
+      2
+    .tick ->
+      1
+  arrayEq [3,2,1], counter.results
+
+
+test "This is a crazy one.", ->
+
+  x = (obj, func) -> func obj
+  ident = (x) -> x
+  result = x {one: ident 1}, (obj) ->
+    inner = ident(obj)
+    ident inner
+  ok result.one is 1
+
+
+test "More paren compilation tests:", ->
+
+  reverse = (obj) -> obj.reverse()
+  ok reverse([1, 2].concat 3).join(' ') is '3 2 1'
+
+
+test "Test for inline functions with parentheses and implicit calls.", ->
+
+  combine = (func, num) -> func() * num
+  result  = combine (-> 1 + 2), 3
+  ok result is 9
+
+
+test "Test for calls/parens/multiline-chains.", ->
+
+  f = (x) -> x
+  result = (f 1).toString()
+    .length
+  ok result is 1
+
+
+test "Test implicit calls in functions in parens:", ->
+
+  result = ((val) ->
+    [].push val
+    val
+  )(10)
+  ok result is 10
+
+
+test "Ensure that chained calls with indented implicit object literals below are alright.", ->
+
+  result = null
+  obj =
+    method: (val)  -> this
+    second: (hash) -> result = hash.three
+  obj
+    .method(
+      101
+    ).second(
+      one:
+        two: 2
+      three: 3
+    )
+  eq result, 3
+
+
+test "Test newline-supressed call chains with nested functions.", ->
+
+  obj  =
+    call: -> this
+  func = ->
+    obj
+      .call ->
+        one two
+      .call ->
+        three four
+    101
+  eq func(), 101
+
+
+test "Implicit objects with number arguments.", ->
+
+  func = (x, y) -> y
+  obj =
+    prop: func "a", 1
+  ok obj.prop is 1
+
+
+test "Non-spaced unary and binary operators should cause a function call.", ->
+
+  func = (val) -> val + 1
+  ok (func +5) is 6
+  ok (func -5) is -4
+
+
+test "Prefix unary assignment operators are allowed in parenless calls.", ->
+
+  func = (val) -> val + 1
+  val = 5
+  ok (func --val) is 5
+
+test "#855: execution context for `func arr...` should be `null`", ->
+  contextTest = -> eq @, if window? then window else global
+  array = []
+  contextTest array
+  contextTest.apply null, array
+  contextTest array...
+
+test "#904: Destructuring function arguments with same-named variables in scope", ->
+  a = b = nonce = {}
+  fn = ([a,b]) -> {a:a,b:b}
+  result = fn([c={},d={}])
+  eq c, result.a
+  eq d, result.b
+  eq nonce, a
+  eq nonce, b
+
+test "Simple Destructuring function arguments with same-named variables in scope", ->
+  x = 1
+  f = ([x]) -> x
+  eq f([2]), 2
+  eq x, 1
+
+test "caching base value", ->
+
+  obj =
+    index: 0
+    0: {method: -> this is obj[0]}
+  ok obj[obj.index++].method([]...)
+
+
+test "passing splats to functions", ->
+  arrayEq [0..4], id id [0..4]...
+  fn = (a, b, c..., d) -> [a, b, c, d]
+  range = [0..3]
+  [first, second, others, last] = fn range..., 4, [5...8]...
+  eq 0, first
+  eq 1, second
+  arrayEq [2..6], others
+  eq 7, last
+
+test "splat variables are local to the function", ->
+  outer = "x"
+  clobber = (avar, outer...) -> outer
+  clobber "foo", "bar"
+  eq "x", outer
+
+
+test "Issue 894: Splatting against constructor-chained functions.", ->
+
+  x = null
+  class Foo
+    bar: (y) -> x = y
+  new Foo().bar([101]...)
+  eq x, 101
+
+
+test "Functions with splats being called with too few arguments.", ->
+
+  pen = null
+  method = (first, variable..., penultimate, ultimate) ->
+    pen = penultimate
+  method 1, 2, 3, 4, 5, 6, 7, 8, 9
+  ok pen is 8
+  method 1, 2, 3
+  ok pen is 2
+  method 1, 2
+  ok pen is 2
+
+
+test "splats with super() within classes.", ->
+
+  class Parent
+    meth: (args...) ->
+      args
+  class Child extends Parent
+    meth: ->
+      nums = [3, 2, 1]
+      super nums...
+  ok (new Child).meth().join(' ') is '3 2 1'
+
+
+test "#1011: passing a splat to a method of a number", ->
+  eq '1011', 11.toString [2]...
+  eq '1011', (31).toString [3]...
+  eq '1011', 69.0.toString [4]...
+  eq '1011', (131.0).toString [5]...
+
+
+test "implicit return", ->
+
+  eq ok, new ->
+    ok
+    ### Should `return` implicitly   ###
+    ### even with trailing comments. ###
+
+
+test "implicit returns with multiple branches", ->
+  nonce = {}
+  fn = ->
+    if false
+      for a in b
+        return c if d
+    else
+      nonce
+  eq nonce, fn()
+
+
+test "implicit returns with switches", ->
+  nonce = {}
+  fn = ->
+    switch nonce
+      when nonce then nonce
+      else return undefined
+  eq nonce, fn()
+
+
+test "preserve context when generating closure wrappers for expression conversions", ->
+  nonce = {}
+  obj =
+    property: nonce
+    method: ->
+      this.result = if false
+        10
+      else
+        "a"
+        "b"
+        this.property
+  eq nonce, obj.method()
+  eq nonce, obj.property
+
+
+test "don't wrap 'pure' statements in a closure", ->
+  nonce = {}
+  items = [0, 1, 2, 3, nonce, 4, 5]
+  fn = (items) ->
+    for item in items
+      return item if item is nonce
+  eq nonce, fn items
+
+
+test "usage of `new` is careful about where the invocation parens end up", ->
+  eq 'object', typeof new try Array
+  eq 'object', typeof new do -> ->
+
+
+test "implicit call against control structures", ->
+  result = null
+  save   = (obj) -> result = obj
+
+  save switch id false
+    when true
+      'true'
+    when false
+      'false'
+
+  eq result, 'false'
+
+  save if id false
+    'false'
+  else
+    'true'
+
+  eq result, 'true'
+
+  save unless id false
+    'true'
+  else
+    'false'
+
+  eq result, 'true'
+
+  save try
+    doesnt exist
+  catch error
+    'caught'
+
+  eq result, 'caught'
+
+  save try doesnt(exist) catch error then 'caught2'
+
+  eq result, 'caught2'
+
+
+test "#1420: things like `(fn() ->)`; there are no words for this one", ->
+  fn = -> (f) -> f()
+  nonce = {}
+  eq nonce, (fn() -> nonce)
+
+test "#1416: don't omit one 'new' when compiling 'new new'", ->
+  nonce = {}
+  obj = new new -> -> {prop: nonce}
+  eq obj.prop, nonce
+
+test "#1416: don't omit one 'new' when compiling 'new new fn()()'", ->
+  nonce = {}
+  argNonceA = {}
+  argNonceB = {}
+  fn = (a) -> (b) -> {a, b, prop: nonce}
+  obj = new new fn(argNonceA)(argNonceB)
+  eq obj.prop, nonce
+  eq obj.a, argNonceA
+  eq obj.b, argNonceB

test/functions.coffee

@@ -1,48 +1,78 @@
-# Arguments
-# ---------
+# Function Literals
+# -----------------
 
-# shared identity function
-id = (_) -> if arguments.length is 1 then _ else Array::slice.call(arguments)
+# TODO: add indexing and method invocation tests: (->)[0], (->).call()
 
-test "basic argument passing tests", ->
-  a = {}
-  b = {}
-  c = {}
-  eq 1, (id 1)
-  eq 2, (id 1, 2)[1]
-  eq a, (id a)
-  eq c, (id a, b, c)[2]
+# * Function Definition
+# * Bound Function Definition
+# * Parameter List Features
+#   * Splat Parameters
+#   * Context (@) Parameters
+#   * Parameter Destructuring
+#   * Default Parameters
 
-test "passing arguments on separate lines", ->
-  a = {}
-  b = {}
-  c = {}
-  ok(id(
-    a
-    b
-    c
-  )[1] is b)
-  eq(0, id(
-    0
-    10
-  )[0])
-  eq(a,id(
-    a
-  ))
-  eq b,
-  (id b)
+# Function Definition
 
-test "reference `arguments` inside of functions", ->
-  sumOfArgs = ->
-    sum = (a,b) -> a + b
-    sum = 0
-    sum += num for num in arguments
-    sum
+x = 1
+y = {}
+y.x = -> 3
+ok x is 1
+ok typeof(y.x) is 'function'
+ok y.x instanceof Function
+ok y.x() is 3
 
-  eq 10, sumOfArgs(0, 1, 2, 3, 4)
+# The empty function should not cause a syntax error.
+->
+() ->
+
+# Multiple nested function declarations mixed with implicit calls should not
+# cause a syntax error.
+(one) -> (two) -> three four, (five) -> six seven, eight, (nine) ->
+
+# with multiple single-line functions on the same line.
+func = (x) -> (x) -> (x) -> x
+ok func(1)(2)(3) is 3
+
+# Make incorrect indentation safe.
+func = ->
+  obj = {
+          key: 10
+        }
+  obj.key - 5
+eq func(), 5
+
+# Ensure that functions with the same name don't clash with helper functions.
+del = -> 5
+ok del() is 5
 
 
-#### Parameter List Features
+# Bound Function Definition
+
+obj =
+  bound: ->
+    (=> this)()
+  unbound: ->
+    (-> this)()
+  nested: ->
+    (=>
+      (=>
+        (=> this)()
+      )()
+    )()
+eq obj, obj.bound()
+ok obj isnt obj.unbound()
+eq obj, obj.nested()
+
+
+test "self-referencing functions", ->
+  changeMe = ->
+    changeMe = 2
+
+  changeMe()
+  eq changeMe, 2
+
+
+# Parameter List Features
 
 test "splats", ->
   arrayEq [0, 1, 2], (((splat...) -> splat) 0, 1, 2)
@@ -125,3 +155,11 @@ test "default values with splatted arguments", ->
   eq  5, withSplats(1,1)
   eq  1, withSplats(1,1,1)
   eq  2, withSplats(1,1,1,1)
+
+test "default values with function calls", ->
+  doesNotThrow -> CoffeeScript.compile "(x = f()) ->"
+
+test "arguments vs parameters", ->
+  doesNotThrow -> CoffeeScript.compile "f(x) ->"
+  f = (g) -> g()
+  eq 5, f (x) -> 5

test/helpers.coffee

@@ -5,7 +5,7 @@
 {starts, ends, compact, count, merge, extend, flatten, del, last} = CoffeeScript.helpers
 
 
-#### `starts`
+# `starts`
 
 test "the `starts` helper tests if a string starts with another string", ->
   ok     starts('01234', '012')
@@ -16,7 +16,7 @@ test "the `starts` helper can take an optional offset", ->
   ok not starts('01234', '01', 1)
 
 
-#### `ends`
+# `ends`
 
 test "the `ends` helper tests if a string ends with another string", ->
   ok     ends('01234', '234')
@@ -27,7 +27,7 @@ test "the `ends` helper can take an optional offset", ->
   ok not ends('01234', '234', 6)
 
 
-#### `compact`
+# `compact`
 
 test "the `compact` helper removes falsey values from an array, preserves truthy ones", ->
   allValues = [1, 0, false, obj={}, [], '', ' ', -1, null, undefined, true]
@@ -35,7 +35,7 @@ test "the `compact` helper removes falsey values from an array, preserves truthy
   arrayEq truthyValues, compact(allValues)
 
 
-#### `count`
+# `count`
 
 test "the `count` helper counts the number of occurances of a string in another string", ->
   eq 1/0, count('abc', '')
@@ -46,7 +46,7 @@ test "the `count` helper counts the number of occurances of a string in another
   eq 2, count('abcdabcd','abc')
 
 
-#### `merge`
+# `merge`
 
 test "the `merge` helper makes a new object with all properties of the objects given as its arguments", ->
   ary = [0, 1, 2, 3, 4]
@@ -58,7 +58,7 @@ test "the `merge` helper makes a new object with all properties of the objects g
     eq val, merged[key]
 
 
-#### `extend`
+# `extend`
 
 test "the `extend` helper performs a shallow copy", ->
   ary = [0, 1, 2, 3]
@@ -69,7 +69,7 @@ test "the `extend` helper performs a shallow copy", ->
   eq 2, obj[2]
 
 
-#### `flatten`
+# `flatten`
 
 test "the `flatten` helper flattens an array", ->
   success = yes
@@ -77,7 +77,7 @@ test "the `flatten` helper flattens an array", ->
   ok success
 
 
-#### `del`
+# `del`
 
 test "the `del` helper deletes a property from an object and returns the deleted value", ->
   obj = [0, 1, 2]
@@ -85,7 +85,7 @@ test "the `del` helper deletes a property from an object and returns the deleted
   ok 1 not of obj
 
 
-#### `last`
+# `last`
 
 test "the `last` helper returns the last item of an array-like object", ->
   ary = [0, 1, 2, 3, 4]

test/interpolation.coffee

@@ -1,23 +1,38 @@
-eq '(((dollars)))', '\(\(\(dollars\)\)\)'
-eq 'one two three', "one
- two
- three"
-eq "four five", 'four
+# Interpolation
+# -------------
 
- five'
+# * String Interpolation
+# * Regular Expression Interpolation
 
-#647
-eq "''Hello, World\\''", '''
-'\'Hello, World\\\''
-'''
-eq '""Hello, World\\""', """
-"\"Hello, World\\\""
-"""
-eq 'Hello, World\n', '''
-Hello, World\
+# String Interpolation
 
-'''
+# TODO: refactor string interpolation tests
 
+eq 'multiline nested "interpolations" work', """multiline #{
+  "nested #{
+    ok true
+    "\"interpolations\""
+  }"
+} work"""
+
+# Issue #923: Tricky interpolation.
+eq "#{ "{" }", "{"
+eq "#{ '#{}}' } }", '#{}} }'
+eq "#{"'#{ ({a: "b#{1}"}['a']) }'"}", "'b1'"
+
+# Issue #1150: String interpolation regression
+eq "#{'"/'}",                '"/'
+eq "#{"/'"}",                "/'"
+eq "#{/'"/}",                '/\'"/'
+eq "#{"'/" + '/"' + /"'/}",  '\'//"/"\'/'
+eq "#{"'/"}#{'/"'}#{/"'/}",  '\'//"/"\'/'
+eq "#{6 / 2}",               '3'
+eq "#{6 / 2}#{6 / 2}",       '33' # parsed as division
+eq "#{6 + /2}#{6/ + 2}",     '6/2}#{6/2' # parsed as a regex
+eq "#{6/2}
+    #{6/2}",                 '3    3' # newline cannot be part of a regex, so it's division
+eq "#{/// "'/'"/" ///}",     '/"\'\\/\'"\\/"/' # heregex, stuffed with spicy characters
+eq "#{/\\'/}",               "/\\\\'/"
 
 hello = 'Hello'
 world = 'World'
@@ -28,37 +43,30 @@ ok "#{hello}##{world}" is 'Hello#World'
 ok "Hello #{ 1 + 2 } World" is 'Hello 3 World'
 ok "#{hello} #{ 1 + 2 } #{world}" is "Hello 3 World"
 
-
 [s, t, r, i, n, g] = ['s', 't', 'r', 'i', 'n', 'g']
 ok "#{s}#{t}#{r}#{i}#{n}#{g}" is 'string'
 ok "\#{s}\#{t}\#{r}\#{i}\#{n}\#{g}" is '#{s}#{t}#{r}#{i}#{n}#{g}'
 ok "\#{string}" is '#{string}'
 
-
 ok "\#{Escaping} first" is '#{Escaping} first'
 ok "Escaping \#{in} middle" is 'Escaping #{in} middle'
 ok "Escaping \#{last}" is 'Escaping #{last}'
 
-
 ok "##" is '##'
 ok "#{}" is ''
 ok "#{}A#{} #{} #{}B#{}" is 'A  B'
 ok "\\\#{}" is '\\#{}'
 
-
 ok "I won ##{20} last night." is 'I won #20 last night.'
 ok "I won ##{'#20'} last night." is 'I won ##20 last night.'
 
-
 ok "#{hello + world}" is 'HelloWorld'
 ok "#{hello + ' ' + world + '!'}" is 'Hello World!'
 
-
 list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 ok "values: #{list.join(', ')}, length: #{list.length}." is 'values: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, length: 10.'
 ok "values: #{list.join ' '}" is 'values: 0 1 2 3 4 5 6 7 8 9'
 
-
 obj = {
   name: 'Joe'
   hi: -> "Hello #{@name}."
@@ -67,7 +75,6 @@ obj = {
 ok obj.hi() is "Hello Joe."
 ok obj.cya() is "Goodbye Joe."
 
-
 ok "With #{"quotes"}" is 'With quotes'
 ok 'With #{"quotes"}' is 'With #{"quotes"}'
 
@@ -78,41 +85,54 @@ ok "Hello #{world ? "#{hello}"}" is 'Hello World'
 
 ok "Hello #{"#{"#{obj["name"]}" + '!'}"}" is 'Hello Joe!'
 
-
 a = """
     Hello #{ "Joe" }
     """
 ok a is "Hello Joe"
 
-
 a = 1
 b = 2
 c = 3
 ok "#{a}#{b}#{c}" is '123'
 
-
 result = null
 stash = (str) -> result = str
 stash "a #{ ('aa').replace /a/g, 'b' } c"
 ok result is 'a bb c'
 
-
 foo = "hello"
 ok "#{foo.replace("\"", "")}" is 'hello'
 
+val = 10
+a = """
+    basic heredoc #{val}
+    on two lines
+    """
+b = '''
+    basic heredoc #{val}
+    on two lines
+    '''
+ok a is "basic heredoc 10\non two lines"
+ok b is "basic heredoc \#{val}\non two lines"
 
 eq 'multiline nested "interpolations" work', """multiline #{
-  "nested #{
-    ok true
+  "nested #{(->
+    ok yes
     "\"interpolations\""
-  }"
+  )()}"
 } work"""
 
 
-# Issue #923: Tricky interpolation.
-eq "#{ "{" }", "{"
+# Regular Expression Interpolation
 
-eq "#{ '#{}}' } }", '#{}} }'
-
-eq "#{"'#{ ({a: "b#{1}"}['a']) }'"}", "'b1'"
+# TODO: improve heregex interpolation tests
 
+test "heregex interpolation", ->
+  eq /\\#{}\\\"/ + '', ///
+   #{
+     "#{ '\\' }" # normal comment
+   }
+   # regex comment
+   \#{}
+   \\ \"
+  /// + ''

test/javascript_literals.coffee

@@ -0,0 +1,10 @@
+# Javascript Literals
+# -------------------
+
+# TODO: refactor javascript literal tests
+# TODO: add indexing and method invocation tests: `[1]`[0] is 1, `function(){}`.call()
+
+eq '\\`', `
+  // Inline JS
+  "\\\`"
+`

test/numbers.coffee

@@ -0,0 +1,48 @@
+# Number Literals
+# ---------------
+
+# * Decimal Integer Literals
+# * Octal Integer Literals
+# * Hexadecimal Integer Literals
+# * Scientific Notation Integer Literals
+# * Scientific Notation Non-Integer Literals
+# * Non-Integer Literals
+
+
+# Decimal Integer Literals
+
+test "call methods directly on numbers", ->
+  eq 4, 4.valueOf()
+  eq '11', 4.toString 3
+
+eq -1, 3 -4
+
+#764: Numbers should be indexable
+eq Number::toString, 42['toString']
+
+eq Number::toString, 42.toString
+
+
+# Non-Integer Literals
+
+# Decimal number literals.
+value = .25 + .75
+ok value is 1
+value = 0.0 + -.25 - -.75 + 0.0
+ok value is 0.5
+
+#764: Numbers should be indexable
+eq Number::toString,   4['toString']
+eq Number::toString, 4.2['toString']
+eq Number::toString, .42['toString']
+eq Number::toString, (4)['toString']
+
+eq Number::toString,   4.toString
+eq Number::toString, 4.2.toString
+eq Number::toString, .42.toString
+eq Number::toString, (4).toString
+
+test '#1168: leading floating point suppresses newline', ->
+	eq 1, do ->
+		1
+		.5 + 0.5

test/objects.coffee

@@ -1,47 +1,14 @@
-a = [((x) -> x), ((x) -> x * x)]
+# Object Literals
+# ---------------
 
-ok a.length is 2
-
-
-neg = (3 -4)
-
-ok neg is -1
-
-
-# Decimal number literals.
-value = .25 + .75
-ok value is 1
-value = 0.0 + -.25 - -.75 + 0.0
-ok value is 0.5
-
-
-# Can call methods directly on numbers.
-4.valueOf() is 4
-
-
-func = ->
-  return if true
-
-ok func() is undefined
-
-
-trailingComma = [1, 2, 3,]
-ok (trailingComma[0] is 1) and (trailingComma[2] is 3) and (trailingComma.length is 3)
-
-trailingComma = [
-  1, 2, 3,
-  4, 5, 6
-  7, 8, 9,
-]
-(sum = (sum or 0) + n) for n in trailingComma
+# TODO: refactor object literal tests
+# TODO: add indexing and method invocation tests: {a}['a'] is a, {a}.a()
 
 trailingComma = {k1: "v1", k2: 4, k3: (-> true),}
 ok trailingComma.k3() and (trailingComma.k2 is 4) and (trailingComma.k1 is "v1")
 
-
 ok {a: (num) -> num is 10 }.a 10
 
-
 moe = {
   name:  'Moe'
   greet: (salutation) ->
@@ -50,138 +17,70 @@ moe = {
     @['greet'] "Hello"
   10: 'number'
 }
-
 ok moe.hello() is "Hello Moe"
 ok moe[10] is 'number'
-
 moe.hello = ->
   this['greet'] "Hello"
-
 ok moe.hello() is 'Hello Moe'
 
-
 obj = {
   is:     -> yes,
   'not':  -> no,
 }
-
 ok obj.is()
 ok not obj.not()
 
-
 ### Top-level object literal... ###
 obj: 1
 ### ...doesn't break things. ###
 
-# Funky indentation within non-comma-seperated arrays.
-result = [['a']
- {b: 'c'}]
-
-ok result[0][0] is 'a'
-ok result[1]['b'] is 'c'
-
-
 # Object literals should be able to include keywords.
 obj = {class: 'höt'}
 obj.function = 'dog'
-
 ok obj.class + obj.function is 'hötdog'
 
-
-# But keyword assignment should be smart enough not to stringify variables.
-func = ->
-  this == 'this'
-
-ok func() is false
+# Implicit objects as part of chained calls.
+pluck = (x) -> x.a
+eq 100, pluck pluck pluck a: a: a: 100
 
 
-# New fancy implicit objects:
-config =
-  development:
-    server: 'localhost'
-    timeout: 10
+test "YAML-style object literals", ->
+  obj =
+    a: 1
+    b: 2
+  eq 1, obj.a
+  eq 2, obj.b
 
-  production:
-    server: 'dreamboat'
-    timeout: 1000
+  config =
+    development:
+      server: 'localhost'
+      timeout: 10
 
-ok config.development.server  is 'localhost'
-ok config.production.server   is 'dreamboat'
-ok config.development.timeout is 10
-ok config.production.timeout  is 1000
+    production:
+      server: 'dreamboat'
+      timeout: 1000
 
-obj =
-  a: 1
-  b: 2
-
-ok obj.a is 1
-ok obj.b is 2
+  ok config.development.server  is 'localhost'
+  ok config.production.server   is 'dreamboat'
+  ok config.development.timeout is 10
+  ok config.production.timeout  is 1000
 
 obj =
   a: 1,
   b: 2,
-
 ok obj.a is 1
 ok obj.b is 2
 
-
 # Implicit objects nesting.
 obj =
   options:
     value: yes
-
   fn: ->
     {}
     null
-
 ok obj.options.value is yes
 ok obj.fn() is null
 
-
-# Implicit arguments to function calls:
-func = (obj) -> obj.a
-func2 = -> arguments
-
-result = func
-  a: 10
-
-ok result is 10
-
-result = func
-  "a": 20
-
-ok result is 20
-
-third = (a, b, c) -> c
-obj =
-  one: 'one'
-  two: third 'one', 'two', 'three'
-
-ok obj.one is 'one'
-ok obj.two is 'three'
-
-a = b = undefined
-
-result = func
-    b:1
-    a
-
-ok result is undefined
-
-result = func
-    a:
-        b:2
-    b:1
-ok result.b is 2
-
-result = func2
-    a:1
-    b
-    c:1
-
-ok result.length is 3
-ok result[2].c is 1
-
 # Implicit objects with wacky indentation:
 obj =
   'reverse': (obj) ->
@@ -202,7 +101,6 @@ obj =
   [],
                   [],
       []]
-
 ok obj.abc().join(' ') is 'a b c'
 ok obj.one.length is 5
 ok obj.one[4] is 4
@@ -212,29 +110,14 @@ ok obj.red.orange.yellow.green is 'blue'
 ok obj.red.indigo is 'violet'
 ok obj.misdent.toString() is ',,,'
 
-second = (x, y) -> y
-obj = then second 'the',
-  1: 1
-  two:
-    three: ->
-      four five,
-        six: seven
-  three: 3
-
-ok obj[1] is 1
-ok obj.three is 3
-
-
-# Implicit objects as part of chained calls.
-pluck = (x) -> x.a
-eq 100, pluck pluck pluck a: a: a: 100
-
-
-eq '\\`', `
-  // Inline JS
-  "\\\`"
-`
+#542: Objects leading expression statement should be parenthesized.
+{f: -> ok yes }.f() + 1
 
+# String-keyed objects shouldn't suppress newlines.
+one =
+  '>!': 3
+six: -> 10
+ok not one.six
 
 # Shorthand objects with property references.
 obj =
@@ -244,27 +127,109 @@ obj =
   two: 2
   object: -> {@one, @two}
   list:   -> [@one, @two]
-
-
 result = obj.object()
 eq result.one, 1
 eq result.two, 2
 eq result.two, obj.list()[1]
 
+third = (a, b, c) -> c
+obj =
+  one: 'one'
+  two: third 'one', 'two', 'three'
+ok obj.one is 'one'
+ok obj.two is 'three'
 
-#542: Objects leading expression statement should be parenthesized.
-{f: -> ok yes }.f() + 1
+test "invoking functions with implicit object literals", ->
+  generateGetter = (prop) -> (obj) -> obj[prop]
+  getA = generateGetter 'a'
+  getArgs = -> arguments
+  a = b = 30
 
+  result = getA
+    a: 10
+  eq 10, result
 
-#764: Boolean/Number should be indexable.
-ok 42['toString']
-ok on['toString']
+  result = getA
+    "a": 20
+  eq 20, result
 
+  result = getA a,
+    b:1
+  eq undefined, result
 
-# String-keyed objects shouldn't suppress newlines.
-one =
-  '>!': 3
-six: -> 10
+  result = getA b:1
+  a:43
+  eq 43, result
 
-ok not one.six
+  result = getA b:1,
+    a:62
+  eq undefined, result
 
+  result = getA
+    b:1
+    a
+  eq undefined, result
+
+  result = getA
+    a:
+      b:2
+    b:1
+  eq 2, result.b
+
+  result = getArgs
+    a:1
+    b
+    c:1
+  ok result.length is 3
+  ok result[2].c is 1
+
+  result = getA b: 13, a: 42, 2
+  eq 42, result
+
+  result = getArgs a:1, (1 + 1)
+  ok result[1] is 2
+
+  result = getArgs a:1, b
+  ok result.length is 2
+  ok result[1] is 30
+
+  result = getArgs a:1, b, b:1, a
+  ok result.length is 4
+  ok result[2].b is 1
+
+  throws -> CoffeeScript.compile "a = b:1, c"
+
+test "some weird indentation in YAML-style object literals", ->
+  two = (a, b) -> b
+  obj = then two 1,
+    1: 1
+    a:
+      b: ->
+        fn c,
+          d: e
+    f: 1
+  eq 1, obj[1]
+
+test "#1274: `{} = a()` compiles to `false` instead of `a()`", ->
+  a = false
+  fn = -> a = true
+  {} = fn()
+  ok a
+
+test "#1436: `for` etc. work as normal property names", ->
+  obj = {}
+  eq no, obj.hasOwnProperty 'for'
+  obj.for = 'foo' of obj
+  eq yes, obj.hasOwnProperty 'for'
+
+test "#1322: implicit call against implicit object with block comments", ->
+  ((obj, arg) ->
+    eq obj.x * obj.y, 6
+    ok not arg
+  )
+    ###
+    x
+    ###
+    x: 2
+    ### y ###
+    y: 3

test/operators.coffee

@@ -1,6 +1,13 @@
 # Operators
 # ---------
 
+# * Operators
+# * Existential Operator (Binary)
+# * Existential Operator (Unary)
+# * Aliased Operators
+# * [not] in/of
+# * Chained Comparison
+
 test "binary (2-ary) math operators do not require spaces", ->
   a = 1
   b = -1
@@ -42,84 +49,72 @@ test "`instanceof`", ->
   ok new Number not instanceof String
   ok new Array not instanceof Boolean
 
+test "use `::` operator on keywords `this` and `@`", ->
+  nonce = {}
+  obj =
+    withAt:   -> @::prop
+    withThis: -> this::prop
+  obj.prototype = prop: nonce
+  eq nonce, obj.withAt()
+  eq nonce, obj.withThis()
 
-#### Compound Assignment Operators
 
-test "boolean operators", ->
+# Existential Operator (Binary)
+
+test "binary existential operator", ->
   nonce = {}
 
-  a  = 0
-  a or= nonce
-  eq nonce, a
+  b = a ? nonce
+  eq nonce, b
 
-  b  = 1
-  b or= nonce
-  eq 1, b
+  a = null
+  b = undefined
+  b = a ? nonce
+  eq nonce, b
 
-  c = 0
-  c and= nonce
-  eq 0, c
+  a = false
+  b = a ? nonce
+  eq false, b
 
-  d = 1
-  d and= nonce
-  eq nonce, d
+  a = 0
+  b = a ? nonce
+  eq 0, b
 
-  # ensure that RHS is treated as a group
-  e = f = false
-  e and= f or true
-  eq false, e
+test "binary existential operator conditionally evaluates second operand", ->
+  i = 1
+  func = -> i -= 1
+  result = func() ? func()
+  eq result, 0
 
-test "compound assignment as a sub expression", ->
-  [a, b, c] = [1, 2, 3]
-  eq 6, (a + b += c)
-  eq 1, a
-  eq 5, b
-  eq 3, c
-
-# *note: this test could still use refactoring*
-test "compound assignment should be careful about caching variables", ->
-  count = 0
-  list = []
-
-  list[++count] or= 1
-  eq 1, list[1]
-  eq 1, count
-
-  list[++count] ?= 2
-  eq 2, list[2]
-  eq 2, count
-
-  list[count++] and= 6
-  eq 6, list[2]
-  eq 3, count
-
-  base = ->
-    ++count
-    base
-
-  base().four or= 4
-  eq 4, base.four
-  eq 4, count
-
-  base().five ?= 5
-  eq 5, base.five
-  eq 5, count
-
-test "compound assignment with implicit objects", ->
-  obj = undefined
-  obj ?=
-    one: 1
-
-  eq 1, obj.one
-
-  obj and=
-    two: 2
-
-  eq undefined, obj.one
-  eq         2, obj.two
+test "binary existential operator with negative number", ->
+  a = null ? - 1
+  eq -1, a
 
 
-#### `is`,`isnt`,`==`,`!=`
+# Existential Operator (Unary)
+
+test "postfix existential operator", ->
+  ok (if nonexistent? then false else true)
+  defined = true
+  ok defined?
+  defined = false
+  ok defined?
+
+test "postfix existential operator only evaluates its operand once", ->
+  semaphore = 0
+  fn = ->
+    ok false if semaphore
+    ++semaphore
+  ok(if fn()? then true else false)
+
+test "negated postfix existential operator", ->
+  ok !nothing?.value
+
+test "postfix existential operator on expressions", ->
+  eq true, (1 or 0)?, true
+
+
+# `is`,`isnt`,`==`,`!=`
 
 test "`==` and `is` should be interchangeable", ->
   a = b = 1
@@ -135,7 +130,7 @@ test "`!=` and `isnt` should be interchangeable", ->
   ok a isnt b
 
 
-#### `in`, `of`
+# [not] in/of
 
 # - `in` should check if an array contains a value using `indexOf`
 # - `of` should check if a property is defined on an object using `in`
@@ -189,8 +184,16 @@ test "#768: `in` should preserve evaluation order", ->
   ok a() not in [b(),c()]
   eq 3, share
 
+test "#1099: empty array after `in` should compile to `false`", ->
+  eq 1, [5 in []].length
+  eq false, do -> return 0 in []
+  
+test "#1354: optimized `in` checks should not happen when splats are present", ->
+  a = [6, 9]
+  eq 9 in [3, a...], true
 
-#### Chainable Operators
+
+# Chained Comparison
 
 test "chainable operators", ->
   ok 100 > 10 > 1 > 0 > -1

test/option_parser.coffee

@@ -1,3 +1,8 @@
+# Option Parser
+# -------------
+
+# TODO: refactor option parser tests
+
 # Ensure that the OptionParser handles arguments correctly.
 return unless require?
 {OptionParser} = require './../lib/optparse'

test/ranges.coffee

@@ -0,0 +1,88 @@
+# Range Literals
+# --------------
+
+# TODO: add indexing and method invocation tests: [1..4][0] is 1, [0...3].toString()
+
+# shared array
+shared = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+test "basic inclusive ranges", ->
+  arrayEq [1, 2, 3] , [1..3]
+  arrayEq [0, 1, 2] , [0..2]
+  arrayEq [0, 1]    , [0..1]
+  arrayEq [0]       , [0..0]
+  arrayEq [-1]      , [-1..-1]
+  arrayEq [-1, 0]   , [-1..0]
+  arrayEq [-1, 0, 1], [-1..1]
+
+test "basic exclusive ranges", ->
+  arrayEq [1, 2, 3] , [1...4]
+  arrayEq [0, 1, 2] , [0...3]
+  arrayEq [0, 1]    , [0...2]
+  arrayEq [0]       , [0...1]
+  arrayEq [-1]      , [-1...0]
+  arrayEq [-1, 0]   , [-1...1]
+  arrayEq [-1, 0, 1], [-1...2]
+
+  arrayEq [], [1...1]
+  arrayEq [], [0...0]
+  arrayEq [], [-1...-1]
+
+test "downward ranges", ->
+  arrayEq shared, [9..0].reverse()
+  arrayEq [5, 4, 3, 2] , [5..2]
+  arrayEq [2, 1, 0, -1], [2..-1]
+
+  arrayEq [3, 2, 1]  , [3..1]
+  arrayEq [2, 1, 0]  , [2..0]
+  arrayEq [1, 0]     , [1..0]
+  arrayEq [0]        , [0..0]
+  arrayEq [-1]       , [-1..-1]
+  arrayEq [0, -1]    , [0..-1]
+  arrayEq [1, 0, -1] , [1..-1]
+  arrayEq [0, -1, -2], [0..-2]
+
+  arrayEq [4, 3, 2], [4...1]
+  arrayEq [3, 2, 1], [3...0]
+  arrayEq [2, 1]   , [2...0]
+  arrayEq [1]      , [1...0]
+  arrayEq []       , [0...0]
+  arrayEq []       , [-1...-1]
+  arrayEq [0]      , [0...-1]
+  arrayEq [0, -1]  , [0...-2]
+  arrayEq [1, 0]   , [1...-1]
+  arrayEq [2, 1, 0], [2...-1]
+
+test "ranges with variables as enpoints", ->
+  [a, b] = [1, 3]
+  arrayEq [1, 2, 3], [a..b]
+  arrayEq [1, 2]   , [a...b]
+  b = -2
+  arrayEq [1, 0, -1, -2], [a..b]
+  arrayEq [1, 0, -1]    , [a...b]
+
+test "ranges with expressions as endpoints", ->
+  [a, b] = [1, 3]
+  arrayEq [2, 3, 4, 5, 6], [(a+1)..2*b]
+  arrayEq [2, 3, 4, 5]   , [(a+1)...2*b]
+
+test "large ranges are generated with looping constructs", ->
+  down = [99..0]
+  eq 100, (len = down.length)
+  eq   0, down[len - 1]
+
+  up = [0...100]
+  eq 100, (len = up.length)
+  eq  99, up[len - 1]
+
+test "#1012 slices with arguments object", ->
+  expected = [0..9]
+  argsAtStart = (-> [arguments[0]..9]) 0
+  arrayEq expected, argsAtStart
+  argsAtEnd = (-> [0..arguments[0]]) 9
+  arrayEq expected, argsAtEnd
+  argsAtBoth = (-> [arguments[0]..arguments[1]]) 0, 9
+  arrayEq expected, argsAtBoth
+
+test "#1409: creating large ranges outside of a function body", ->
+  CoffeeScript.eval '[0..100]'

test/regexps.coffee

@@ -1,6 +1,10 @@
-# Regular Expressions
-# -------------------
-#TODO: add some rigorous regex interpolation tests
+# Regular Expression Literals
+# ---------------------------
+
+# TODO: add method invocation tests: /regex/.toString()
+
+# * Regexen
+# * Heregexen
 
 test "basic regular expression literals", ->
   ok 'a'.match(/a/)
@@ -16,6 +20,10 @@ test "division is not confused for a regular expression", ->
   g = 1
   eq 2, a / b/g
 
+  a = 10
+  b = a /= 4 / 2
+  eq a, 5
+
   obj = method: -> 2
   two = 2
   eq 2, (obj.method()/two + obj.method()/two)
@@ -24,9 +32,6 @@ test "division is not confused for a regular expression", ->
   eq 2, (4)/2/i
   eq 1, i/i/i
 
-test "backslash escapes", ->
-  eq "\\/\\\\", /\/\\/.source
-
 test "#764: regular expressions should be indexable", ->
   eq /0/['source'], ///#{0}///['source']
 
@@ -34,7 +39,7 @@ test "#584: slashes are allowed unescaped in character classes", ->
   ok /^a\/[/]b$/.test 'a//b'
 
 
-#### Heregexe(n|s)
+# Heregexe(n|s)
 
 test "a heregex will ignore whitespace and comments", ->
   eq /^I'm\x20+[a]\s+Heregex?\/\/\//gim + '', ///
@@ -42,15 +47,5 @@ test "a heregex will ignore whitespace and comments", ->
     Heregex? / // # or not
   ///gim + ''
 
-test "heregex interpolation", ->
-  eq /\\#{}\\\"/ + '', ///
-   #{
-     "#{ '\\' }" # normal comment
-   }
-   # regex comment
-   \#{}
-   \\ \"
-  /// + ''
-
 test "an empty heregex will compile to an empty, non-capturing group", ->
   eq /(?:)/ + '', ///  /// + ''

test/repl.coffee

@@ -0,0 +1,4 @@
+# REPL
+# ----
+
+# TODO: add tests

test/scope.coffee

@@ -0,0 +1,34 @@
+# Scope
+# -----
+
+# * Variable Safety
+# * Variable Shadowing
+# * Auto-closure (`do`)
+# * Global Scope Leaks
+
+test "reference `arguments` inside of functions", ->
+  sumOfArgs = ->
+    sum = (a,b) -> a + b
+    sum = 0
+    sum += num for num in arguments
+    sum
+  eq 10, sumOfArgs(0, 1, 2, 3, 4)
+
+test "assignment to an Object.prototype-named variable should not leak to outer scope", ->
+  # FIXME: fails on IE
+  (->
+    constructor = 'word'
+  )()
+  ok constructor isnt 'word'
+
+test "siblings of splat parameters shouldn't leak to surrounding scope", ->
+  x = 10
+  oops = (x, args...) ->
+  oops(20, 1, 2, 3)
+  eq x, 10
+
+test "catch statements should introduce their argument to scope", ->
+  try throw ''
+  catch e
+    do -> e = 5
+    eq 5, e

test/slicing_and_splicing.coffee

@@ -1,83 +1,13 @@
-# Ranges, Slices, and Splices
-# ---------------------------
+# Slicing and Splicing
+# --------------------
+
+# * Slicing
+# * Splicing
 
 # shared array
 shared = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
-
-#### Ranges
-
-test "basic inclusive ranges", ->
-  arrayEq [1, 2, 3] , [1..3]
-  arrayEq [0, 1, 2] , [0..2]
-  arrayEq [0, 1]    , [0..1]
-  arrayEq [0]       , [0..0]
-  arrayEq [-1]      , [-1..-1]
-  arrayEq [-1, 0]   , [-1..0]
-  arrayEq [-1, 0, 1], [-1..1]
-
-test "basic exclusive ranges", ->
-  arrayEq [1, 2, 3] , [1...4]
-  arrayEq [0, 1, 2] , [0...3]
-  arrayEq [0, 1]    , [0...2]
-  arrayEq [0]       , [0...1]
-  arrayEq [-1]      , [-1...0]
-  arrayEq [-1, 0]   , [-1...1]
-  arrayEq [-1, 0, 1], [-1...2]
-
-  arrayEq [], [1...1]
-  arrayEq [], [0...0]
-  arrayEq [], [-1...-1]
-
-test "downward ranges", ->
-  arrayEq shared, [9..0].reverse()
-  arrayEq [5, 4, 3, 2] , [5..2]
-  arrayEq [2, 1, 0, -1], [2..-1]
-
-  arrayEq [3, 2, 1]  , [3..1]
-  arrayEq [2, 1, 0]  , [2..0]
-  arrayEq [1, 0]     , [1..0]
-  arrayEq [0]        , [0..0]
-  arrayEq [-1]       , [-1..-1]
-  arrayEq [0, -1]    , [0..-1]
-  arrayEq [1, 0, -1] , [1..-1]
-  arrayEq [0, -1, -2], [0..-2]
-
-  arrayEq [4, 3, 2], [4...1]
-  arrayEq [3, 2, 1], [3...0]
-  arrayEq [2, 1]   , [2...0]
-  arrayEq [1]      , [1...0]
-  arrayEq []       , [0...0]
-  arrayEq []       , [-1...-1]
-  arrayEq [0]      , [0...-1]
-  arrayEq [0, -1]  , [0...-2]
-  arrayEq [1, 0]   , [1...-1]
-  arrayEq [2, 1, 0], [2...-1]
-
-test "ranges with variables as enpoints", ->
-  [a, b] = [1, 3]
-  arrayEq [1, 2, 3], [a..b]
-  arrayEq [1, 2]   , [a...b]
-  b = -2
-  arrayEq [1, 0, -1, -2], [a..b]
-  arrayEq [1, 0, -1]    , [a...b]
-
-test "ranges with expressions as endpoints", ->
-  [a, b] = [1, 3]
-  arrayEq [2, 3, 4, 5, 6], [(a+1)..2*b]
-  arrayEq [2, 3, 4, 5]   , [(a+1)...2*b]
-
-test "large ranges are generated with looping constructs", ->
-  down = [99..0]
-  eq 100, (len = down.length)
-  eq   0, down[len - 1]
-
-  up = [0...100]
-  eq 100, (len = up.length)
-  eq  99, up[len - 1]
-
-
-#### Slices
+# Slicing
 
 test "basic slicing", ->
   arrayEq [7, 8, 9]   , shared[7..9]
@@ -123,7 +53,7 @@ test "string slicing", ->
   ok str[-5..] is "vwxyz"
 
 
-#### Splices
+# Splicing
 
 test "basic splicing", ->
   ary = [0..9]

test/soaks.coffee

@@ -0,0 +1,134 @@
+# Soaks
+# -----
+
+# * Soaked Property Access
+# * Soaked Method Invocation
+# * Soaked Function Invocation
+
+
+# Soaked Property Access
+
+test "soaked property access", ->
+  nonce = {}
+  obj = a: b: nonce
+  eq nonce    , obj?.a.b
+  eq nonce    , obj?['a'].b
+  eq nonce    , obj.a?.b
+  eq nonce    , obj?.a?['b']
+  eq undefined, obj?.a?.non?.existent?.property
+
+test "soaked property access caches method calls", ->
+  nonce ={}
+  obj = fn: -> a: nonce
+  eq nonce    , obj.fn()?.a
+  eq undefined, obj.fn()?.b
+
+test "soaked property access chaching", ->
+  nonce = {}
+  counter = 0
+  fn = ->
+    counter++
+    'self'
+  obj =
+    self: -> @
+    prop: nonce
+  eq nonce, obj[fn()]()[fn()]()[fn()]()?.prop
+  eq 3, counter
+
+test "method calls on soaked methods", ->
+  nonce = {}
+  obj = null
+  eq undefined, obj?.a().b()
+  obj = a: -> b: -> nonce
+  eq nonce    , obj?.a().b()
+
+test "postfix existential operator mixes well with soaked property accesses", ->
+  eq false, nonexistent?.property?
+
+test "function invocation with soaked property access", ->
+  id = (_) -> _
+  eq undefined, id nonexistent?.method()
+
+test "if-to-ternary should safely parenthesize soaked property accesses", ->
+  ok (if nonexistent?.property then false else true)
+
+test "#726", ->
+  # TODO: check this test, looks like it's not really testing anything
+  eq undefined, nonexistent?[Date()]
+
+test "#756", ->
+  # TODO: improve this test
+  a = null
+  ok isNaN      a?.b.c +  1
+  eq undefined, a?.b.c += 1
+  eq undefined, ++a?.b.c
+  eq undefined, delete a?.b.c
+
+test "operations on soaked properties", ->
+  # TODO: improve this test
+  a = b: {c: 0}
+  eq 1,   a?.b.c +  1
+  eq 1,   a?.b.c += 1
+  eq 2,   ++a?.b.c
+  eq yes, delete a?.b.c
+
+
+# Soaked Method Invocation
+
+test "soaked method invocation", ->
+  nonce = {}
+  counter = 0
+  obj =
+    self: -> @
+    increment: -> counter++; @
+  eq obj      , obj.self?()
+  eq undefined, obj.method?()
+  eq nonce    , obj.self?().property = nonce
+  eq undefined, obj.method?().property = nonce
+  eq obj      , obj.increment().increment().self?()
+  eq 2        , counter
+
+test "#733", ->
+  a = b: {c: null}
+  eq a.b?.c?(), undefined
+  a.b?.c or= (it) -> it
+  eq a.b?.c?(1), 1
+  eq a.b?.c?([2, 3]...), 2
+
+
+# Soaked Function Invocation
+
+test "soaked function invocation", ->
+  nonce = {}
+  id = (_) -> _
+  eq nonce    , id?(nonce)
+  eq nonce    , (id? nonce)
+  eq undefined, nonexistent?(nonce)
+  eq undefined, (nonexistent? nonce)
+
+test "soaked function invocation with generated functions", ->
+  nonce = {}
+  id = (_) -> _
+  maybe = (fn, arg) -> if typeof fn is 'function' then () -> fn(arg)
+  eq maybe(id, nonce)?(), nonce
+  eq (maybe id, nonce)?(), nonce
+  eq (maybe false, nonce)?(), undefined
+
+test "soaked constructor invocation", ->
+  eq 42       , +new Number? 42
+  eq undefined,  new Other?  42
+
+test "soaked constructor invocations with caching and property access", ->
+  semaphore = 0
+  nonce = {}
+  class C
+    constructor: ->
+      ok false if semaphore
+      semaphore++
+    prop: nonce
+  eq nonce, (new C())?.prop
+  eq 1, semaphore
+
+test "soaked function invocation safe on non-functions", ->
+  eq undefined, 0?(1)
+  eq undefined, 0? 1, 2

test/strings.coffee

@@ -1,86 +1,85 @@
+# String Literals
+# ---------------
+
+# TODO: refactor string literal tests
+# TODO: add indexing and method invocation tests: "string"["toString"] is String::toString, "string".toString() is "string"
+
+# * Strings
+# * Heredocs
+
+test "backslash escapes", ->
+  eq "\\/\\\\", /\/\\/.source
+
+eq '(((dollars)))', '\(\(\(dollars\)\)\)'
+eq 'one two three', "one
+ two
+ three"
+eq "four five", 'four
+
+ five'
+
+#647
+eq "''Hello, World\\''", '''
+'\'Hello, World\\\''
+'''
+eq '""Hello, World\\""', """
+"\"Hello, World\\\""
+"""
+eq 'Hello, World\n', '''
+Hello, World\
+
+'''
+
 a = """
     basic heredoc
     on two lines
     """
-
 ok a is "basic heredoc\non two lines"
 
-
 a = '''
     a
       "b
     c
     '''
-
 ok a is "a\n  \"b\nc"
 
-
 a = """
 a
  b
   c
 """
-
 ok a is "a\n b\n  c"
 
-
 a = '''one-liner'''
-
 ok a is 'one-liner'
 
-
 a = """
       out
       here
 """
-
 ok a is "out\nhere"
 
-
 a = '''
        a
      b
    c
     '''
-
 ok a is "    a\n  b\nc"
 
-
 a = '''
 a
 
 
 b c
 '''
-
 ok a is "a\n\n\nb c"
 
-
 a = '''more"than"one"quote'''
-
 ok a is 'more"than"one"quote'
 
-
-val = 10
-
-a = """
-    basic heredoc #{val}
-    on two lines
-    """
-
-b = '''
-    basic heredoc #{val}
-    on two lines
-    '''
-
-ok a is "basic heredoc 10\non two lines"
-ok b is "basic heredoc \#{val}\non two lines"
-
-
 a = '''here's an apostrophe'''
 ok a is "here's an apostrophe"
 
-
 # The indentation detector ignores blank lines without trailing whitespace
 a = """
     one
@@ -103,9 +102,6 @@ eq """ "\\\" """, ' "\\" '
 
 eq '''  <- keep these spaces ->  ''', '  <- keep these spaces ->  '
 
-eq 'multiline nested "interpolations" work', """multiline #{
-  "nested #{(->
-    ok yes
-    "\"interpolations\""
-  )()}"
-} work"""
+
+test "#1046, empty string interpolations", ->
+  eq "#{ }", ''

test/test.html

@@ -27,10 +27,9 @@
   start   = new Date
   success = total = done = failed = 0
 
-  say = (msg, yay) ->
+  say = (msg) ->
     div = document.createElement 'div'
     div.appendChild document.createTextNode msg
-    div.style.color = if yay then 'green' else 'red'
     stdout.appendChild div
     msg
 
@@ -72,16 +71,9 @@
       return
     ok no
 
-
-  CoffeeScript.run = (code, cb) ->
-    try Function(CoffeeScript.compile code, wrap: no)()
-    catch e then cb(); throw e
-    cb yes
-
   run = (name) ->
-    CoffeeScript.load "#{name}.coffee", (yay) ->
-      say "#{ if yay then '\u2714' else '\u3000' } #{name}", yay
-      ++failed unless yay
+    CoffeeScript.load "#{name}.coffee", ->
+      say '\u2714 ' + name
       fin() if ++done is names.length
 
   fin = ->
@@ -92,30 +84,33 @@
     say msg, yay
 
   run name for name in names = [
-    'arguments'
+    'arrays'
     'assignment'
-    'break'
+    'booleans'
+    'classes'
     'comments'
+    'compilation'
+    'comprehensions'
+    'control_flow'
     'exception_handling'
+    'formatting'
+    'function_invocation'
+    'functions'
     'helpers'
+    'importing'
+    'interpolation'
+    'javascript_literals'
+    'numbers'
+    'objects'
     'operators'
-    'regular_expressions'
-    'test_chaining'
-    'test_classes'
-    'test_compilation'
-    'test_comprehensions'
-    'test_existence'
-    'test_functions'
-    'test_heredocs'
-    'conditionals'
-    'test_literals'
-    'test_pattern_matching'
-    'ranges_slices_and_splices'
-    'test_returns'
-    'test_splats'
-    'test_strings'
-    'test_switch'
-    'test_while'
+    'option_parser'
+    'ranges'
+    'regexps'
+    'repl'
+    'scope'
+    'slicing_and_splicing'
+    'soaks'
+    'strings'
   ]
   </script>
 

test/test_chaining.coffee

@@ -1,77 +0,0 @@
-# Chaining
-# --------
-
-# shared identity function
-id = (_) -> if arguments.length is 1 then _ else Array::slice.call(arguments)
-
-
-
-# Basic chained function calls.
-identityWrap = (x) ->
-  -> x
-
-result = identityWrap(identityWrap(true))()()
-
-ok result
-
-
-# Should be able to look at prototypes on keywords.
-obj =
-  withAt:   -> @::prop
-  withThis: -> this::prop
-  proto:
-    prop: 100
-obj.prototype = obj.proto
-eq obj.withAt()  , 100
-eq obj.withThis(), 100
-
-
-# Chained accesses split on period/newline, backwards and forwards.
-str = 'god'
-
-result = str.
-  split('').
-  reverse().
-  reverse().
-  reverse()
-
-ok result.join('') is 'dog'
-
-result = str
-  .split('')
-  .reverse()
-  .reverse()
-  .reverse()
-
-ok result.join('') is 'dog'
-
-
-# Newline suppression for operators.
-six =
-  1 +
-  2 +
-  3
-
-ok six is 6
-
-
-# Ensure that indented array literals don't trigger whitespace rewriting.
-func = () ->
-  ok arguments.length is 1
-
-func(
-  [[[[[],
-                []],
-              [[]]]],
-    []])
-
-greeting = id(
-              """
-              Hello
-              """)
-
-ok greeting is "Hello"
-
-ok not Date
-::
-?.foo, '`?.` and `::` should also continue lines'

test/test_classes.coffee

@@ -1,372 +0,0 @@
-# Test classes with a four-level inheritance chain.
-class Base
-  func: (string) ->
-    "zero/#{string}"
-
-  @static: (string) ->
-    "static/#{string}"
-
-class FirstChild extends Base
-  func: (string) ->
-    super('one/') + string
-
-SecondChild = class extends FirstChild
-  func: (string) ->
-    super('two/') + string
-
-thirdCtor = ->
-  @array = [1, 2, 3]
-
-class ThirdChild extends SecondChild
-  constructor: -> thirdCtor.call this
-
-  # Gratuitous comment for testing.
-  func: (string) ->
-    super('three/') + string
-
-result = (new ThirdChild).func 'four'
-
-ok result is 'zero/one/two/three/four'
-ok Base.static('word') is 'static/word'
-
-FirstChild::func = (string) ->
-  super('one/').length + string
-
-result = (new ThirdChild).func 'four'
-
-ok result is '9two/three/four'
-
-ok (new ThirdChild).array.join(' ') is '1 2 3'
-
-
-identity = (f) -> f
-
-class TopClass
-  constructor: (arg) ->
-    @prop = 'top-' + arg
-
-class SuperClass extends TopClass
-  constructor: (arg) ->
-    identity super 'super-' + arg
-
-class SubClass extends SuperClass
-  constructor: ->
-    identity super 'sub'
-
-ok (new SubClass).prop is 'top-super-sub'
-
-
-class OneClass
-  @new: 'new'
-  function: 'function'
-  constructor: (name) -> @name = name
-
-class TwoClass extends OneClass
-delete TwoClass.new
-
-Function.prototype.new = -> new this arguments...
-
-ok (TwoClass.new('three')).name is 'three'
-ok (new OneClass).function is 'function'
-ok OneClass.new is 'new'
-
-delete Function.prototype.new
-
-
-# And now the same tests, but written in the manual style:
-Base = ->
-Base::func = (string) ->
-  'zero/' + string
-Base::['func-func'] = (string) ->
-  "dynamic-#{string}"
-
-FirstChild = ->
-SecondChild = ->
-ThirdChild = ->
-  @array = [1, 2, 3]
-  this
-
-ThirdChild extends SecondChild extends FirstChild extends Base
-
-FirstChild::func = (string) ->
-  super('one/') + string
-
-SecondChild::func = (string) ->
-  super('two/') + string
-
-ThirdChild::func = (string) ->
-  super('three/') + string
-
-result = (new ThirdChild).func 'four'
-
-ok result is 'zero/one/two/three/four'
-
-ok (new ThirdChild)['func-func']('thing') is 'dynamic-thing'
-
-
-TopClass = (arg) ->
-  @prop = 'top-' + arg
-  this
-
-SuperClass = (arg) ->
-  super 'super-' + arg
-  this
-
-SubClass = ->
-  super 'sub'
-  this
-
-SuperClass extends TopClass
-SubClass extends SuperClass
-
-ok (new SubClass).prop is 'top-super-sub'
-
-
-# '@' referring to the current instance, and not being coerced into a call.
-class ClassName
-  amI: ->
-    @ instanceof ClassName
-
-obj = new ClassName
-ok obj.amI()
-
-
-# super() calls in constructors of classes that are defined as object properties.
-class Hive
-  constructor: (name) -> @name = name
-
-class Hive.Bee extends Hive
-  constructor: (name) -> super
-
-maya = new Hive.Bee 'Maya'
-ok maya.name is 'Maya'
-
-
-# Class with JS-keyword properties.
-class Class
-  class: 'class'
-  name: -> @class
-
-instance = new Class
-ok instance.class is 'class'
-ok instance.name() is 'class'
-
-
-# Classes with methods that are pre-bound to the instance.
-# ... or statically, to the class.
-class Dog
-
-  constructor: (name) ->
-    @name = name
-
-  bark: =>
-    "#{@name} woofs!"
-
-  @static = =>
-    new this('Dog')
-
-spark = new Dog('Spark')
-fido  = new Dog('Fido')
-fido.bark = spark.bark
-
-ok fido.bark() is 'Spark woofs!'
-
-obj = func: Dog.static
-
-ok obj.func().name is 'Dog'
-
-
-# Testing a bound function in a bound function.
-class Mini
-  num: 10
-  generate: =>
-    for i in [1..3]
-      =>
-        @num
-
-m = new Mini
-eq (func() for func in m.generate()).join(' '), '10 10 10'
-
-
-# Testing a contructor called with varargs.
-class Connection
-  constructor: (one, two, three) ->
-    [@one, @two, @three] = [one, two, three]
-
-  out: ->
-    "#{@one}-#{@two}-#{@three}"
-
-list = [3, 2, 1]
-conn = new Connection list...
-ok conn instanceof Connection
-ok conn.out() is '3-2-1'
-
-
-# Test calling super and passing along all arguments.
-class Parent
-  method: (args...) -> @args = args
-
-class Child extends Parent
-  method: -> super
-
-c = new Child
-c.method 1, 2, 3, 4
-ok c.args.join(' ') is '1 2 3 4'
-
-
-# Test classes wrapped in decorators.
-func = (klass) ->
-  klass::prop = 'value'
-  klass
-
-func class Test
-  prop2: 'value2'
-
-ok (new Test).prop  is 'value'
-ok (new Test).prop2 is 'value2'
-
-
-# Test anonymous classes.
-obj =
-  klass: class
-    method: -> 'value'
-
-instance = new obj.klass
-ok instance.method() is 'value'
-
-
-# Implicit objects as static properties.
-class Static
-  @static =
-    one: 1
-    two: 2
-
-ok Static.static.one is 1
-ok Static.static.two is 2
-
-
-# Nothing classes.
-c = class
-ok c instanceof Function
-
-
-# Classes with value'd constructors.
-counter = 0
-classMaker = ->
-  counter += 1
-  inner = counter
-  ->
-    @value = inner
-
-class One
-  constructor: classMaker()
-
-class Two
-  constructor: classMaker()
-
-ok (new One).value is 1
-ok (new Two).value is 2
-ok (new One).value is 1
-ok (new Two).value is 2
-
-
-# Exectuable class bodies.
-class A
-  if true
-    b: 'b'
-  else
-    c: 'c'
-
-a = new A
-
-eq a.b, 'b'
-eq a.c, undefined
-
-
-# Light metaprogramming.
-class Base
-  @attr: (name) ->
-    @::[name] = (val) ->
-      if arguments.length > 0
-        @["_#{name}"] = val
-      else
-        @["_#{name}"]
-
-class Robot extends Base
-  @attr 'power'
-  @attr 'speed'
-
-robby = new Robot
-
-ok robby.power() is undefined
-
-robby.power 11
-robby.speed Infinity
-
-eq robby.power(), 11
-eq robby.speed(), Infinity
-
-
-# Namespaced classes do not reserve their function name in outside scope.
-one = {}
-two = {}
-
-class one.Klass
-  @label = "one"
-
-class two.Klass
-  @label = "two"
-
-eq typeof Klass, 'undefined'
-eq one.Klass.label, 'one'
-eq two.Klass.label, 'two'
-
-
-# Nested classes.
-class Outer
-  constructor: ->
-    @label = 'outer'
-
-  class @Inner
-    constructor: ->
-      @label = 'inner'
-
-eq (new Outer).label, 'outer'
-eq (new Outer.Inner).label, 'inner'
-
-
-# Variables in constructor bodies are correctly scoped.
-class A
-  x = 1
-  constructor: ->
-    x = 10
-    y = 20
-  y = 2
-  captured: ->
-    {x, y}
-
-a = new A
-eq a.captured().x, 10
-eq a.captured().y, 2
-
-
-# Issue #924: Static methods in nested classes.
-class A
-  @B: class
-    @c = -> 5
-
-eq A.B.c(), 5
-
-
-# `class extends this` ...
-class A
-  func: -> 'A'
-
-B = null
-makeClass = ->
-  B = class extends this
-    func: -> super + ' B'
-
-makeClass.call A
-
-eq (new B()).func(), 'A B'

test/test_compilation.coffee

@@ -1,26 +0,0 @@
-# Ensure that carriage returns don't break compilation on Windows.
-eq CoffeeScript.compile('one\r\ntwo', bare: on), 'one;\ntwo;'
-
-# `globals: on` removes `var`s
-eq CoffeeScript.compile('x = y', bare: on, globals: on), 'x = y;'
-
-ok 'passed' is CoffeeScript.eval '"passed"', bare: on, fileName: 'test'
-
-#750
-try ok not CoffeeScript.nodes 'f(->'
-catch e then eq e.message, 'unclosed CALL_START on line 1'
-
-eq CoffeeScript.compile('for k of o then', bare: on, globals: on),
-   'for (k in o) {}'
-
-# Compilations that should fail.
-cantCompile = (code) ->
-  throws -> CoffeeScript.compile code
-
-cantCompile 'a = (break)'
-
-cantCompile 'a = (return 5 for item in list)'
-
-cantCompile 'a = (return 5 while condition)'
-
-cantCompile 'a = for x in y\n  return 5'

test/test_comprehensions.coffee

@@ -1,318 +0,0 @@
-# Basic array comprehensions.
-nums    = (n * n for n in [1, 2, 3] when n & 1)
-results = (n * 2 for n in nums)
-
-ok results.join(',') is '2,18'
-
-
-# Basic object comprehensions.
-obj   = {one: 1, two: 2, three: 3}
-names = (prop + '!' for prop of obj)
-odds  = (prop + '!' for prop, value of obj when value & 1)
-
-ok names.join(' ') is "one! two! three!"
-ok odds.join(' ')  is "one! three!"
-
-
-# Basic range comprehensions.
-nums = (i * 3 for i in [1..3])
-
-negs = (x for x in [-20..-5*2])
-negs = negs[0..2]
-
-result = nums.concat(negs).join(', ')
-
-ok result is '3, 6, 9, -20, -19, -18'
-
-
-# With range comprehensions, you can loop in steps.
-results = (x for x in [0...15] by 5)
-ok results.join(' ') is '0 5 10'
-
-results = (x for x in [0..100] by 10)
-ok results.join(' ') is '0 10 20 30 40 50 60 70 80 90 100'
-
-
-# And can loop downwards, with a negative step.
-results = (x for x in [5..1])
-
-ok results.join(' ') is '5 4 3 2 1'
-ok results.join(' ') is [(10-5)..(-2+3)].join(' ')
-
-results = (x for x in [10..1])
-ok results.join(' ') is [10..1].join(' ')
-
-results = (x for x in [10...0] by -2)
-ok results.join(' ') is [10, 8, 6, 4, 2].join(' ')
-
-
-# Range comprehension gymnastics.
-eq "#{i for i in [5..1]}", '5,4,3,2,1'
-eq "#{i for i in [5..-5] by -5}", '5,0,-5'
-
-a = 6
-b = 0
-c = -2
-
-eq "#{i for i in [a..b]}", '6,5,4,3,2,1,0'
-eq "#{i for i in [a..b] by c}", '6,4,2,0'
-
-
-# Multiline array comprehension with filter.
-evens = for num in [1, 2, 3, 4, 5, 6] when not (num & 1)
-           num *= -1
-           num -= 2
-           num * -1
-eq evens + '', '4,6,8'
-
-
-# The in operator still works, standalone.
-ok 2 of evens
-
-# all isn't reserved.
-all = 1
-
-
-# Ensure that the closure wrapper preserves local variables.
-obj = {}
-
-for method in ['one', 'two', 'three'] then do (method) ->
-  obj[method] = ->
-    "I'm " + method
-
-ok obj.one()   is "I'm one"
-ok obj.two()   is "I'm two"
-ok obj.three() is "I'm three"
-
-
-# Index values at the end of a loop.
-i = 0
-for i in [1..3]
-  -> 'func'
-  break if false
-ok i is 4
-
-
-# Ensure that local variables are closed over for range comprehensions.
-funcs = for i in [1..3]
-  do (i) ->
-    -> -i
-
-eq (func() for func in funcs).join(' '), '-1 -2 -3'
-ok i is 4
-
-
-# Even when referenced in the filter.
-list = ['one', 'two', 'three']
-
-methods = for num, i in list when num isnt 'two' and i isnt 1
-  do (num, i) ->
-    -> num + ' ' + i
-
-ok methods.length is 2
-ok methods[0]() is 'one 0'
-ok methods[1]() is 'three 2'
-
-
-# Even a convoluted one.
-funcs = []
-
-for i in [1..3]
-  do (i) ->
-    x = i * 2
-    ((z)->
-      funcs.push -> z + ' ' + i
-    )(x)
-
-ok (func() for func in funcs).join(', ') is '2 1, 4 2, 6 3'
-
-funcs = []
-
-results = for i in [1..3]
-  do (i) ->
-    z = (x * 3 for x in [1..i])
-    ((a, b, c) -> [a, b, c].join(' ')).apply this, z
-
-ok results.join(', ') is '3  , 3 6 , 3 6 9'
-
-
-# Naked ranges are expanded into arrays.
-array = [0..10]
-ok(num % 2 is 0 for num in array by 2)
-
-
-# Nested shared scopes.
-foo = ->
-  for i in [0..7]
-    do (i) ->
-      for j in [0..7]
-        do (j) ->
-          -> i + j
-
-eq foo()[3][4](), 7
-
-
-# Scoped loop pattern matching.
-a = [[0], [1]]
-funcs = []
-
-for [v] in a
-  do (v) ->
-    funcs.push -> v
-
-eq funcs[0](), 0
-eq funcs[1](), 1
-
-
-# Nested comprehensions.
-multiLiner =
-  for x in [3..5]
-    for y in [3..5]
-      [x, y]
-
-singleLiner =
-  (([x, y] for y in [3..5]) for x in [3..5])
-
-ok multiLiner.length is singleLiner.length
-ok 5 is multiLiner[2][2][1]
-ok 5 is singleLiner[2][2][1]
-
-
-# Comprehensions within parentheses.
-result = null
-store = (obj) -> result = obj
-store (x * 2 for x in [3, 2, 1])
-
-ok result.join(' ') is '6 4 2'
-
-
-# Closure-wrapped comprehensions that refer to the "arguments" object.
-expr = ->
-  result = (item * item for item in arguments)
-
-ok expr(2, 4, 8).join(' ') is '4 16 64'
-
-
-# Fast object comprehensions over all properties, including prototypal ones.
-class Cat
-  constructor: -> @name = 'Whiskers'
-  breed: 'tabby'
-  hair:  'cream'
-
-whiskers = new Cat
-own = (value for own key, value of whiskers)
-all = (value for key, value of whiskers)
-
-ok own.join(' ') is 'Whiskers'
-ok all.sort().join(' ') is 'Whiskers cream tabby'
-
-
-# Optimized range comprehensions.
-exxes = ('x' for [0...10])
-ok exxes.join(' ') is 'x x x x x x x x x x'
-
-
-# Comprehensions safely redeclare parameters if they're not present in closest
-# scope.
-rule = (x) -> x
-
-learn = ->
-  rule for rule in [1, 2, 3]
-
-ok learn().join(' ') is '1 2 3'
-
-ok rule(101) is 101
-
-f = -> [-> ok no, 'should cache source']
-ok yes for k of [f] = f()
-
-
-# Lenient on pure statements not trying to reach out of the closure
-val = for i in [1]
-  for j in [] then break
-  i
-ok val[0] is i
-
-
-# Comprehensions only wrap their last line in a closure, allowing other lines
-# to have pure expressions in them.
-func = -> for i in [1]
-  break if i is 2
-  j for j in [1]
-
-ok func()[0][0] is 1
-
-i = 6
-odds = while i--
-  continue unless i & 1
-  i
-
-ok odds.join(', ') is '5, 3, 1'
-
-
-# Issue #897: Ensure that plucked function variables aren't leaked.
-facets = {}
-list = ['one', 'two']
-
-(->
-  for entity in list
-    facets[entity] = -> entity
-)()
-
-eq typeof entity, 'undefined'
-eq facets['two'](), 'two'
-
-
-# Issue #905. Soaks as the for loop subject.
-a = {b: {c: [1, 2, 3]}}
-for d in a.b?.c
-  e = d
-
-eq e, 3
-
-
-# Issue #948. Capturing loop variables.
-funcs = []
-list  = ->
-  [1, 2, 3]
-
-for y in list()
-  do (y) ->
-    z = y
-    funcs.push -> "y is #{y} and z is #{z}"
-
-eq funcs[1](), "y is 2 and z is 2"
-
-
-# Cancel the comprehension if there's a jump inside the loop.
-result = try
-  for i in [0...10]
-    continue if i < 5
-  i
-
-eq result, 10
-
-
-# Comprehensions over break.
-arrayEq (break for [1..10]), []
-
-# Comprehensions over continue.
-arrayEq (break for [1..10]), []
-
-
-# Comprehensions over function literals.
-a = 0
-for f in [-> a = 1]
-  do (f) ->
-    do f
-
-eq a, 1
-
-
-# Comprehensions that mention arguments.
-list = [arguments: 10]
-args = for f in list
-  do (f) ->
-    f.arguments
-
-eq args[0], 10

test/test_existence.coffee

@@ -1,165 +0,0 @@
-ok(if mySpecialVariable? then false else true)
-
-mySpecialVariable = false
-
-ok(if mySpecialVariable? then true else false)
-
-
-# Existential assignment.
-a = 5
-a = null
-a ?= 10
-b ?= 10
-
-ok a is 10 and b is 10
-
-
-# The existential operator.
-z = null
-x = z ? "EX"
-ok z is null and x is "EX"
-
-i = 9
-func = -> i += 1
-result = func() ? 101
-ok result is 10
-
-# Only evaluate once.
-counter = 0
-getNextNode = ->
-  throw "up" if counter
-  counter++
-
-ok(if getNextNode()? then true else false)
-
-
-# Existence chains, soaking up undefined properties:
-obj =
-  prop: "hello"
-
-eq obj?.prop, "hello"
-eq obj?['prop'], "hello"
-eq obj.prop?.length, 5
-eq obj?.prop?['length'], 5
-eq obj?.prop?.non?.existent?.property, undefined
-
-
-# Soaks and caches method calls as well.
-arr = ["--", "----"]
-
-eq arr.pop()?.length, 4
-eq arr.pop()?.length, 2
-eq arr.pop()?.length, undefined
-eq arr.pop()?.length?.non?.existent()?.property, undefined
-
-
-# Soaks method calls safely.
-value = null
-eq value?.toString().toLowerCase(), undefined
-
-value = 10
-eq value?.toString().toLowerCase(), '10'
-
-eq 0.nothing?.property() or 101, 101
-
-counter = 0
-func = ->
-  counter += 1
-  'prop'
-obj =
-  prop: -> this
-  value: 25
-
-ok obj[func()]()[func()]()[func()]()?.value is 25
-ok counter is 3
-
-
-ident = (obj) -> obj
-eq ident(non?.existent().method()), undefined, 'soaks inner values'
-
-
-# Soaks constructor invocations.
-a = 0
-class Foo
-  constructor: -> a += 1
-  bar: "bat"
-
-ok (new Foo())?.bar is 'bat'
-ok a is 1
-
-
-ok not value?.property?, 'safely checks existence on soaks'
-
-
-eq nothing?.value, undefined, 'safely calls values off of non-existent variables'
-eq !nothing?.value and 1, 1,  'corresponding operators work as expected'
-
-
-# Assign to the result of an exsitential operation with a minus.
-x = null ? - 1
-ok x is - 1
-
-
-# Things that compile to ternaries should force parentheses, like operators do.
-duration = if options?.animated then 150 else 0
-ok duration is 0
-
-
-# Function soaks.
-plus1 = (x) -> x + 1
-count = 0
-obj = {
-  counter: -> count += 1; this
-  returnThis: -> this
-}
-
-eq plus1?(41), 42
-eq (plus1? 41), 42
-eq plus2?(41), undefined
-eq (plus2? 41), undefined
-eq obj.returnThis?(), obj
-eq obj.returnSelf?(), undefined
-eq obj.returnThis?().flag = on, on
-eq obj.returnSelf?().flag = on, undefined
-eq obj.counter().counter().returnThis?(), obj
-eq count, 2
-
-maybe_close = (f, arg) -> if typeof f is 'function' then () -> f(arg) else -1
-
-eq maybe_close(plus1, 41)?(), 42
-eq (maybe_close plus1, 41)?(), 42
-eq (maybe_close 'string', 41)?(), undefined
-
-eq 2?(3), undefined
-eq new Number?(42) | 0, 42
-eq new Bumper?(42) | 0, 0
-
-
-#726
-eq calendar?[Date()], undefined
-
-
-#733
-a = b: {c: null}
-eq a.b?.c?(), undefined
-
-a.b?.c or= (it) -> it
-eq a.b?.c?(1), 1
-eq a.b?.c?([2, 3]...), 2
-
-
-#756
-a = null
-ok isNaN      a?.b.c +  1
-eq undefined, a?.b.c += 1
-eq undefined, ++a?.b.c
-eq undefined, delete a?.b.c
-
-a = b: {c: 0}
-eq 1,   a?.b.c +  1
-eq 1,   a?.b.c += 1
-eq 2,   ++a?.b.c
-eq yes, delete a?.b.c
-
-
-eq (1 or 0)?, true, 'postfix `?` should unwrap correctly'

test/test_functions.coffee

@@ -1,379 +0,0 @@
-x = 1
-y = {}
-y.x = -> 3
-
-ok x is 1
-ok typeof(y.x) is 'function'
-ok y.x instanceof Function
-ok y.x() is 3
-
-
-# The empty function should not cause a syntax error.
-->
-() ->
-
-
-# Multiple nested function declarations mixed with implicit calls should not
-# cause a syntax error.
-(one) -> (two) -> three four, (five) -> six seven, eight, (nine) ->
-
-
-obj = {
-  name: 'Fred'
-
-  bound: ->
-    do (=> eq this, obj)
-
-  unbound: ->
-    do (-> ok this isnt obj)
-
-  nested: ->
-    (=>
-      do (=>
-        (=>
-          eq this, obj
-        )()
-      )
-    )()
-}
-
-obj.unbound()
-obj.bound()
-obj.nested()
-
-
-# Python decorator style wrapper that memoizes any function
-memoize = (fn) ->
-  cache = {}
-  self  = this
-  (args...) ->
-    key = args.toString()
-    return cache[key] if cache[key]
-    cache[key] = fn.apply(self, args)
-
-Math = {
-  Add: (a, b) -> a + b
-  AnonymousAdd: (a, b) -> a + b
-  FastAdd: memoize (a, b) -> a + b
-}
-
-ok Math.Add(5, 5) is 10
-ok Math.AnonymousAdd(10, 10) is 20
-ok Math.FastAdd(20, 20) is 40
-
-
-okFunc = (f) -> ok(f())
-okFunc -> true
-
-# Optional parens can be used in a nested fashion.
-call = (func) -> func()
-
-result = call ->
-  inner = call ->
-    Math.Add(5, 5)
-
-ok result is 10
-
-
-# More fun with optional parens.
-fn = (arg) -> arg
-
-ok fn(fn {prop: 101}).prop is 101
-
-
-# Multi-blocks with optional parens.
-result = fn( ->
-  fn ->
-    "Wrapped"
-)
-
-ok result()() is 'Wrapped'
-
-
-# And even with strange things like this:
-funcs  = [((x) -> x), ((x) -> x * x)]
-result = funcs[1] 5
-
-ok result is 25
-
-result = ("hello".slice) 3
-
-ok result is 'lo'
-
-
-# And with multiple single-line functions on the same line.
-func = (x) -> (x) -> (x) -> x
-ok func(1)(2)(3) is 3
-
-
-# Ensure that functions with the same name don't clash with helper functions.
-del = -> 5
-ok del() is 5
-
-# Ensure that functions can have a trailing comma in their argument list
-mult = (x, mids..., y) ->
-  x *= n for n in mids
-  x *= y
-
-ok mult(1, 2,) is 2
-ok mult(1, 2, 3,) is 6
-ok mult(10, (i for i in [1..6])...) is 7200
-
-
-# Test for inline functions with parentheses and implicit calls.
-combine = (func, num) -> func() * num
-result  = combine (-> 1 + 2), 3
-
-ok result is 9
-
-
-# Test for calls/parens/multiline-chains.
-f = (x) -> x
-result = (f 1).toString()
-  .length
-
-ok result is 1
-
-
-# Test implicit calls in functions in parens:
-result = ((val) ->
-  [].push val
-  val
-)(10)
-
-ok result is 10
-
-
-# More paren compilation tests:
-reverse = (obj) -> obj.reverse()
-ok reverse([1, 2].concat 3).join(' ') is '3 2 1'
-
-# Passing multiple functions without paren-wrapping is legal, and should compile.
-sum = (one, two) -> one() + two()
-result = sum ->
-  7 + 9
-, ->
-  1 + 3
-
-ok result is 20
-
-
-# Implicit call with a trailing if statement as a param.
-func = -> arguments[1]
-result = func 'one', if false then 100 else 13
-ok result is 13
-
-
-# Test more function passing:
-result = sum( ->
-  1 + 2
-, ->
-  2 + 1
-)
-ok result is 6
-
-sum = (a, b) -> a + b
-result = sum(1
-, 2)
-
-ok result is 3
-
-
-# This is a crazy one.
-x = (obj, func) -> func obj
-ident = (x) -> x
-
-result = x {one: ident 1}, (obj) ->
-  inner = ident(obj)
-  ident inner
-
-ok result.one is 1
-
-
-# Assignment to a Object.prototype-named variable should not leak to outer scope.
-# FIXME: fails on IE
-(->
-  constructor = 'word'
-)()
-
-ok constructor isnt 'word'
-
-
-# Trying an implicit object call with a trailing function.
-a = null
-meth = (arg, obj, func) -> a = [obj.a, arg, func()].join ' '
-
-meth 'apple', b: 1, a: 13, ->
-  'orange'
-
-ok a is '13 apple orange'
-
-
-# Ensure that empty functions don't return mistaken values.
-obj =
-  func: (@param, @rest...) ->
-
-ok obj.func(101, 102, 103, 104) is undefined
-ok obj.param is 101
-ok obj.rest.join(' ') is '102 103 104'
-
-
-# `@` and `this` should both be able to invoke a method.
-func          = (arg) -> ok arg is true
-func.withAt   = -> @ true
-func.withThis = -> this true
-
-func.withAt()
-func.withThis()
-
-
-# Ensure that constructors invoked with splats return a new object.
-args = [1, 2, 3]
-Type = (@args) ->
-type = new Type args
-
-ok type and type instanceof Type
-ok type.args and type.args instanceof Array
-ok v is args[i] for v, i in type.args
-
-Type1 = (@a, @b, @c) ->
-type1 = new Type1 args...
-
-ok type1 instanceof   Type1
-eq type1.constructor, Type1
-ok type1.a is args[0] and type1.b is args[1] and type1.c is args[2]
-
-
-# Ensure that constructors invoked with splats cache the function.
-called = 0
-get = -> if called++ then false else class Type
-new get() args...
-
-
-# Chained blocks, with proper indentation levels:
-counter =
-  results: []
-  tick: (func) ->
-    @results.push func()
-    this
-
-counter
-  .tick ->
-    3
-  .tick ->
-    2
-  .tick ->
-    1
-
-eq counter.results.join(' '), '3 2 1'
-
-
-# Make incorrect indentation safe.
-func = ->
-  obj = {
-          key: 10
-        }
-  obj.key - 5
-
-eq func(), 5
-
-
-# Ensure that chained calls with indented implicit object literals below are
-# alright.
-result = null
-obj =
-  method: (val)  -> this
-  second: (hash) -> result = hash.three
-
-
-obj
-  .method(
-    101
-  ).second(
-    one:
-      two: 2
-    three: 3
-  )
-
-eq result, 3
-
-
-# Test newline-supressed call chains with nested functions.
-obj  =
-  call: -> this
-func = ->
-  obj
-    .call ->
-      one two
-    .call ->
-      three four
-  101
-
-eq func(), 101
-
-
-# `new` shouldn't add extra parens
-ok new Date().constructor is Date
-
-
-# `new` works against bare function
-eq Date, new ->
-  eq this, new => this
-  Date
-
-
-# Implicit objects with number arguments.
-func = (x, y) -> y
-obj =
-  prop: func "a", 1
-
-ok obj.prop is 1
-
-
-# Non-spaced unary and binary operators should cause a function call.
-func = (val) -> val + 1
-ok (func +5) is 6
-ok (func -5) is -4
-
-
-# Prefix unary assignment operators are allowed in parenless calls.
-val = 5
-ok (func --val) is 5
-
-
-eq ok, new ->
-  ok
-  ### Should `return` implicitly   ###
-  ### even with trailing comments. ###
-
-
-#855: execution context for `func arr...` should be `null`
-(->
-  global = @
-  contextTest = -> ok global is @
-  array = []
-  contextTest array
-  contextTest.apply null, array
-  contextTest array...
-)()
-
-
-# #894: Splatting against constructor-chained functions.
-x = null
-
-class Foo
-  bar: (y) -> x = y
-
-new Foo().bar([101]...)
-
-eq x, 101
-
-
-test "#904: Destructuring function arguments with same-named variables in scope", ->
-  a = b = nonce = {}
-  fn = ([a,b]) -> {a:a,b:b}
-  result = fn([c={},d={}])
-  eq c, result.a
-  eq d, result.b
-  eq nonce, a
-  eq nonce, b

test/test_pattern_matching.coffee

@@ -1,162 +0,0 @@
-# Simple variable swapping.
-a = -1
-b = -2
-
-[a, b] = [b, a]
-
-eq a, -2
-eq b, -1
-
-func = ->
-  [a, b] = [b, a]
-
-eq func().join(' '), '-1 -2'
-eq a, -1
-eq b, -2
-
-#713
-eq (onetwo = [1, 2]), [a, b] = [c, d] = onetwo
-ok a is c is 1 and b is d is 2
-
-
-# Array destructuring, including splats.
-[x,y...,z] = [1,2,3,4,5]
-
-ok x is 1
-ok y.length is 3
-ok z is 5
-
-[x, [y, mids..., last], z..., end] = [1, [10, 20, 30, 40], 2,3,4, 5]
-
-ok x is 1
-ok y is 10
-ok mids.length is 2 and mids[1] is 30
-ok last is 40
-ok z.length is 3 and z[2] is 4
-ok end is 5
-
-
-# Object destructuring.
-obj = {x: 10, y: 20, z: 30}
-
-{x: a, y: b, z: c} = obj
-
-ok a is 10
-ok b is 20
-ok c is 30
-
-person = {
-  name: "Moe"
-  family: {
-    'elder-brother': {
-      addresses: [
-        "first"
-        {
-          street: "101 Deercreek Ln."
-          city:   "Moquasset NY, 10021"
-        }
-      ]
-    }
-  }
-}
-
-{name: a, family: {'elder-brother': {addresses: [one, {city: b}]}}} = person
-
-ok a is "Moe"
-ok b is "Moquasset NY, 10021"
-
-test = {
-  person: {
-    address: [
-      "------"
-      "Street 101"
-      "Apt 101"
-      "City 101"
-    ]
-  }
-}
-
-{person: {address: [ignore, addr...]}} = test
-
-ok addr.join(', ') is "Street 101, Apt 101, City 101"
-
-
-# Pattern matching against an expression.
-[a, b] = if true then [2, 1] else [1, 2]
-
-ok a is 2
-ok b is 1
-
-
-# Pattern matching with object shorthand.
-
-person = {
-  name: "Bob"
-  age:  26
-  dogs: ["Prince", "Bowie"]
-}
-
-{name, age, dogs: [first, second]} = person
-
-ok name   is "Bob"
-ok age    is 26
-ok first  is "Prince"
-ok second is "Bowie"
-
-# Pattern matching within for..loops.
-
-persons = {
-  George: { name: "Bob" },
-  Bob: { name: "Alice" }
-  Christopher: { name: "Stan" }
-}
-
-join1 = ("#{key}: #{name}" for key, { name } of persons)
-
-eq join1.join(' / '), "George: Bob / Bob: Alice / Christopher: Stan"
-
-persons = [
-  { name: "Bob", parent: { name: "George" } },
-  { name: "Alice", parent: { name: "Bob" } },
-  { name: "Stan", parent: { name: "Christopher" } }
-]
-
-join2 = ("#{parent}: #{name}" for { name, parent: { name: parent } } in persons)
-
-eq join1.join(' '), join2.join(' ')
-
-persons = [['Bob', ['George']], ['Alice', ['Bob']], ['Stan', ['Christopher']]]
-join3 = ("#{parent}: #{name}" for [name, [parent]] in persons)
-
-eq join2.join(' '), join3.join(' ')
-
-
-# Pattern matching doesn't clash with implicit block objects.
-obj = a: 101
-func = -> true
-
-if func func
-  {a} = obj
-
-ok a is 101
-
-[x] = {0: y} = {'0': z} = [Math.random()]
-ok x is y is z, 'destructuring in multiple'
-
-
-# Destructuring into an object.
-obj =
-  func: (list, object) ->
-    [@one, @two] = list
-    {@a, @b} = object
-    {@a} = object
-    null
-
-{} = [] = ok yes, 'empty assignment is allowed'
-
-obj.func [1, 2], a: 'a', b: 'b'
-
-eq obj.one, 1
-eq obj.two, 2
-eq obj.a, 'a'
-eq obj.b, 'b'

test/test_returns.coffee

@@ -1,63 +0,0 @@
-# Expression conversion under explicit returns.
-first = ->
-  return ('do' for x in [1,2,3])
-
-second = ->
-  return ['re' for x in [1,2,3]]
-
-third = ->
-  return ('mi' for x in [1,2,3])
-
-ok first().join(' ')     is 'do do do'
-ok second()[0].join(' ') is 're re re'
-ok third().join(' ')     is 'mi mi mi'
-
-
-# Testing returns with multiple branches.
-func = ->
-  if false
-    for a in b
-      return c if d
-  else
-    "word"
-
-ok func() is 'word'
-
-
-# And with switches.
-func = ->
-  switch 'a'
-    when 'a' then 42
-    else return 23
-
-eq func(), 42
-
-# Ensure that we don't wrap Nodes that are "pureStatement" in a closure.
-items = [1, 2, 3, "bacon", 4, 5]
-
-findit = (items) ->
-  for item in items
-    return item if item is "bacon"
-
-ok findit(items) is "bacon"
-
-
-# When a closure wrapper is generated for expression conversion, make sure
-# that references to "this" within the wrapper are safely converted as well.
-obj =
-  num: 5
-  func: ->
-    this.result = if false
-      10
-    else
-      "a"
-      "b"
-      this.num
-
-eq obj.num, obj.func()
-eq obj.num, obj.result
-
-
-# Multiple semicolon-separated statements in parentheticals.
-eq 3, (1; 2; 3)
-eq 3, (-> return (1; 2; 3))()

test/test_splats.coffee

@@ -1,102 +0,0 @@
-# Splats
-# ------
-# note: splats in parameter lists of function definitions are tested in `arguments.coffee`
-
-# shared identity function
-id = (_) -> if arguments.length is 1 then _ else Array::slice.call(arguments)
-
-test "passing splats to functions", ->
-  arrayEq [0..4], id id [0..4]...
-
-  fn = (a, b, c..., d) -> [a, b, c, d]
-  [first, second, others, last] = fn [0..3]..., 4, [5...8]...
-  eq 0, first
-  eq 1, second
-  arrayEq [2..6], others
-  eq 7, last
-
-
-obj =
-  name: 'moe'
-  accessor: (args...) ->
-    [@name].concat(args).join(' ')
-  getNames: ->
-    args = ['jane', 'ted']
-    @accessor(args...)
-  index: 0
-  0: {method: -> this is obj[0]}
-
-ok obj.getNames() is 'moe jane ted'
-ok obj[obj.index++].method([]...), 'should cache base value'
-
-#crowd = [
-#  contenders...
-#  "Mighty Mouse"
-#]
-#
-#bests = [
-#  "Mighty Mouse"
-#  contenders.slice(0, 4)...
-#]
-#
-#ok crowd[0] is contenders[0]
-#ok crowd[10] is "Mighty Mouse"
-#
-#ok bests[1] is contenders[0]
-#ok bests[4] is contenders[3]
-
-
-# Finally, splats with super() within classes.
-
-class Parent
-  meth: (args...) ->
-    args
-
-class Child extends Parent
-  meth: ->
-    nums = [3, 2, 1]
-    super nums...
-
-ok (new Child).meth().join(' ') is '3 2 1'
-
-
-# Functions with splats being called with too few arguments.
-pen = null
-method = (first, variable..., penultimate, ultimate) ->
-  pen = penultimate
-
-method 1, 2, 3, 4, 5, 6, 7, 8, 9
-ok pen is 8
-
-method 1, 2, 3
-ok pen is 2
-
-method 1, 2
-ok pen is 2
-
-
-# Array splat expansions with assigns.
-nums = [1, 2, 3]
-list = [a = 0, nums..., b = 4]
-ok a is 0
-ok b is 4
-ok list.join(' ') is '0 1 2 3 4'
-
-
-# Splat on a line by itself is invalid.
-failed = true
-try
-  CoffeeScript.compile "x 'a'\n...\n"
-  failed = false
-catch err
-ok failed
-
-
-# multiple generated references
-(->
-  a = {b: []}
-  a.b[true] = -> this == a.b
-  c = 0
-  d = []
-  ok a.b[0<++c<2] d...
-)()

test/test_switch.coffee

@@ -1,103 +0,0 @@
-num = 10
-
-result = switch num
-  when 5 then false
-  when 'a'
-    true
-    true
-    false
-  when 10 then true
-
-
-  # Mid-switch comment with whitespace
-  # and multi line
-  when 11 then false
-  else false
-
-ok result
-
-
-func = (num) ->
-  switch num
-    when 2, 4, 6
-      true
-    when 1, 3, 5
-      false
-
-ok func(2)
-ok func(6)
-ok !func(3)
-eq func(8), undefined
-
-
-# Ensure that trailing switch elses don't get rewritten.
-result = false
-switch "word"
-  when "one thing"
-    doSomething()
-  else
-    result = true unless false
-
-ok result
-
-result = false
-switch "word"
-  when "one thing"
-    doSomething()
-  when "other thing"
-    doSomething()
-  else
-    result = true unless false
-
-ok result
-
-
-# Should be able to handle switches sans-condition.
-result = switch
-  when null                     then 0
-  when !1                       then 1
-  when '' not of {''}           then 2
-  when [] not instanceof Array  then 3
-  when true is false            then 4
-  when 'x' < 'y' > 'z'          then 5
-  when 'a' in ['b', 'c']        then 6
-  when 'd' in (['e', 'f'])      then 7
-  else ok
-
-eq result, ok
-
-
-# Should be able to use "@properties" within the switch clause.
-obj = {
-  num: 101
-  func: ->
-    switch @num
-      when 101 then '101!'
-      else 'other'
-}
-
-ok obj.func() is '101!'
-
-
-# Should be able to use "@properties" within the switch cases.
-obj = {
-  num: 101
-  func: (yesOrNo) ->
-    result = switch yesOrNo
-      when yes then @num
-      else 'other'
-    result
-}
-
-ok obj.func(yes) is 101
-
-
-# Switch with break as the return value of a loop.
-i = 10
-results = while i > 0
-  i--
-  switch i % 2
-    when 1 then i
-    when 0 then break
-
-eq results.join(', '), '9, , 7, , 5, , 3, , 1, '