coffee-script 0.1.6 → 0.2.0

data/lib/coffee_script/lexer.rb

@@ -12,69 +12,80 @@ module CoffeeScript
                   "new", "return",
                   "try", "catch", "finally", "throw",
                   "break", "continue",
-                  "for", "in", "while",
+                  "for", "in", "by", "where", "while",
                   "switch", "when",
                   "super", "extends",
                   "delete", "instanceof", "typeof"]
 
     # Token matching regexes.
     IDENTIFIER = /\A([a-zA-Z$_]\w*)/
-    NUMBER     = /\A((\b|-)((0(x|X)[0-9a-fA-F]+)|([0-9]+(\.[0-9]+)?(e[+\-]?[0-9]+)?)))\b/i
+    NUMBER     = /\A(\b((0(x|X)[0-9a-fA-F]+)|([0-9]+(\.[0-9]+)?(e[+\-]?[0-9]+)?)))\b/i
     STRING     = /\A(""|''|"(.*?)[^\\]"|'(.*?)[^\\]')/m
     JS         = /\A(``|`(.*?)[^\\]`)/m
     OPERATOR   = /\A([+\*&|\/\-%=<>:!]+)/
-    WHITESPACE = /\A([ \t\r]+)/
-    NEWLINE    = /\A(\n+)/
-    COMMENT    = /\A((#[^\n]*\s*)+)/m
+    WHITESPACE = /\A([ \t]+)/
+    COMMENT    = /\A(((\n?[ \t]*)?#.*$)+)/
     CODE       = /\A(=>)/
     REGEX      = /\A(\/(.*?)[^\\]\/[imgy]{0,4})/
+    MULTI_DENT = /\A((\n([ \t]*)?)+)/
+    LAST_DENT  = /\n([ \t]*)/
+    ASSIGNMENT = /\A(:|=)\Z/
 
     # Token cleaning regexes.
     JS_CLEANER = /(\A`|`\Z)/
     MULTILINER = /\n/
     COMMENT_CLEANER = /(^\s*#|\n\s*$)/
+    NO_NEWLINE = /\A([+\*&|\/\-%=<>:!.\\][<>=&|]*|and|or|is|isnt|not|delete|typeof|instanceof)\Z/
 
-    # Tokens that always constitute the start of an expression.
-    EXP_START  = ['{', '(', '[']
-
-    # Tokens that always constitute the end of an expression.
-    EXP_END    = ['}', ')', ']']
-
-    # Assignment tokens.
-    ASSIGN     = [':', '=']
+    # Tokens which a regular expression will never immediately follow, but which
+    # a division operator might.
+    # See: http://www.mozilla.org/js/language/js20-2002-04/rationale/syntax.html#regular-expressions
+    NOT_REGEX  = [
+      :IDENTIFIER, :NUMBER, :REGEX, :STRING,
+      ')', '++', '--', ']', '}',
+      :FALSE, :NULL, :THIS, :TRUE
+    ]
 
     # Scan by attempting to match tokens one character at a time. Slow and steady.
     def tokenize(code)
       @code = code.chomp  # Cleanup code by remove extra line breaks
       @i = 0              # Current character position we're parsing
       @line = 1           # The current line.
+      @indent = 0         # The current indent level.
+      @indents = []       # The stack of all indent levels we are currently within.
       @tokens = []        # Collection of all parsed tokens in the form [:TOKEN_TYPE, value]
       while @i < @code.length
         @chunk = @code[@i..-1]
         extract_next_token
       end
-      @tokens
+      puts "original stream: #{@tokens.inspect}" if ENV['VERBOSE']
+      close_indentation
+      Rewriter.new.rewrite(@tokens)
     end
 
-    # At every position, run this list of match attempts, short-circuiting if
-    # any of them succeed.
+    # At every position, run through this list of attempted matches,
+    # short-circuiting if any of them succeed.
     def extract_next_token
       return if identifier_token
       return if number_token
       return if string_token
       return if js_token
       return if regex_token
+      return if indent_token
       return if comment_token
       return if whitespace_token
       return    literal_token
     end
 
+    # Tokenizers ==========================================================
+
     # Matches identifying literals: variables, keywords, method names, etc.
     def identifier_token
       return false unless identifier = @chunk[IDENTIFIER, 1]
-      # Keywords are special identifiers tagged with their own name, 'if' will result
-      # in an [:IF, "if"] token
+      # Keywords are special identifiers tagged with their own name,
+      # 'if' will result in an [:IF, "if"] token.
       tag = KEYWORDS.include?(identifier) ? identifier.upcase.to_sym : :IDENTIFIER
+      tag = :LEADING_WHEN if tag == :WHEN && [:OUTDENT, :INDENT, "\n"].include?(last_tag)
       @tokens[-1][0] = :PROPERTY_ACCESS if tag == :IDENTIFIER && last_value == '.' && !(@tokens[-2][1] == '.')
       token(tag, identifier)
       @i += identifier.length
@@ -108,6 +119,7 @@ module CoffeeScript
     # Matches regular expression literals.
     def regex_token
       return false unless regex = @chunk[REGEX, 1]
+      return false if NOT_REGEX.include?(last_tag)
       token(:REGEX, regex)
       @i += regex.length
     end
@@ -121,73 +133,105 @@ module CoffeeScript
       @i += comment.length
     end
 
+    # Record tokens for indentation differing from the previous line.
+    def indent_token
+      return false unless indent = @chunk[MULTI_DENT, 1]
+      @line += indent.scan(MULTILINER).size
+      @i += indent.size
+      return suppress_newlines(indent) if last_value.to_s.match(NO_NEWLINE) && last_value != "=>"
+      size = indent.scan(LAST_DENT).last.last.length
+      return newline_token(indent) if size == @indent
+      if size > @indent
+        token(:INDENT, size - @indent)
+        @indents << (size - @indent)
+      else
+        outdent_token(@indent - size)
+      end
+      @indent = size
+    end
+
+    # Record an oudent token or tokens, if we're moving back inwards past
+    # multiple recorded indents.
+    def outdent_token(move_out)
+      while move_out > 0 && !@indents.empty?
+        last_indent = @indents.pop
+        token(:OUTDENT, last_indent)
+        move_out -= last_indent
+      end
+      token("\n", "\n")
+    end
+
     # Matches and consumes non-meaningful whitespace.
     def whitespace_token
       return false unless whitespace = @chunk[WHITESPACE, 1]
       @i += whitespace.length
     end
 
+    # Multiple newlines get merged together.
+    # Use a trailing \ to escape newlines.
+    def newline_token(newlines)
+      token("\n", "\n") unless last_value == "\n"
+      true
+    end
+
+    # Tokens to explicitly escape newlines are removed once their job is done.
+    def suppress_newlines(newlines)
+      @tokens.pop if last_value == "\\"
+      true
+    end
+
     # We treat all other single characters as a token. Eg.: ( ) , . !
     # Multi-character operators are also literal tokens, so that Racc can assign
-    # the proper order of operations. Multiple newlines get merged together.
-    # Use a trailing \ to escape newlines.
+    # the proper order of operations.
     def literal_token
-      value = @chunk[NEWLINE, 1]
-      if value
-        @line += value.length
-        token("\n", "\n") unless ["\n", "\\"].include?(last_value)
-        @tokens.pop if last_value == "\\"
-        return @i += value.length
-      end
       value = @chunk[OPERATOR, 1]
       tag_parameters if value && value.match(CODE)
       value ||= @chunk[0,1]
-      skip_following_newlines if EXP_START.include?(value)
-      remove_leading_newlines if EXP_END.include?(value)
-      tag = ASSIGN.include?(value) ? :ASSIGN : value
+      tag = value.match(ASSIGNMENT) ? :ASSIGN : value
       token(tag, value)
       @i += value.length
     end
 
+    # Helpers ==========================================================
+
     # Add a token to the results, taking note of the line number, and
     # immediately-preceding comment.
     def token(tag, value)
       @tokens << [tag, Value.new(value, @line)]
     end
 
-    # Peek at the previous token.
+    # Peek at the previous token's value.
     def last_value
       @tokens.last && @tokens.last[1]
     end
 
+    # Peek at the previous token's tag.
+    def last_tag
+      @tokens.last && @tokens.last[0]
+    end
+
     # A source of ambiguity in our grammar was parameter lists in function
     # definitions (as opposed to argument lists in function calls). Tag
-    # parameter identifiers in order to avoid this.
+    # parameter identifiers in order to avoid this. Also, parameter lists can
+    # make use of splats.
     def tag_parameters
-      index = 0
+      i = 0
       loop do
-        tok = @tokens[index -= 1]
+        i -= 1
+        tok = @tokens[i]
         return if !tok
         next if tok[0] == ','
+        next tok[0] = :PARAM_SPLAT if tok[0] == '*'
         return if tok[0] != :IDENTIFIER
         tok[0] = :PARAM
       end
     end
 
-    # Consume and ignore newlines immediately after this point.
-    def skip_following_newlines
-      newlines = @code[(@i+1)..-1][NEWLINE, 1]
-      if newlines
-        @line += newlines.length
-        @i += newlines.length
-      end
-    end
-
-    # Discard newlines immediately before this point.
-    def remove_leading_newlines
-      @tokens.pop if last_value == "\n"
+    # Close up all remaining open blocks. IF the first token is an indent,
+    # axe it.
+    def close_indentation
+      outdent_token(@indent)
     end
 
   end
-
 end

data/lib/coffee_script/narwhal/coffee-script.coffee

@@ -15,15 +15,16 @@ coffeePath: File.path(module.path).dirname().dirname().dirname().dirname().dirna
 checkForErrors: coffeeProcess =>
   return true if coffeeProcess.wait() is 0
   system.stderr.print(coffeeProcess.stderr.read())
-  throw new Error("CoffeeScript compile error").
+  throw new Error("CoffeeScript compile error")
 
 # Run a simple REPL, round-tripping to the CoffeeScript compiler for every
 # command.
 exports.run: args =>
-  args.shift()
   if args.length
-    exports.evalCS(File.read(path)) for path in args.
-    return true.
+    for path, i in args
+      exports.evalCS(File.read(path))
+      delete args[i]
+    return true
 
   while true
     try
@@ -31,31 +32,31 @@ exports.run: args =>
       result: exports.evalCS(Readline.readline())
       print(result) if result isnt undefined
     catch e
-      print(e)...
+      print(e)
 
 # Compile a given CoffeeScript file into JavaScript.
 exports.compileFile: path =>
   coffee: OS.popen([coffeePath, "--print", "--no-wrap", path])
   checkForErrors(coffee)
-  coffee.stdout.read().
+  coffee.stdout.read()
 
 # Compile a string of CoffeeScript into JavaScript.
 exports.compile: source =>
   coffee: OS.popen([coffeePath, "--eval", "--no-wrap"])
   coffee.stdin.write(source).flush().close()
   checkForErrors(coffee)
-  coffee.stdout.read().
+  coffee.stdout.read()
 
 # Evaluating a string of CoffeeScript first compiles it externally.
 exports.evalCS: source =>
-  eval(exports.compile(source)).
+  eval(exports.compile(source))
 
 # Make a factory for the CoffeeScript environment.
 exports.makeNarwhalFactory: path =>
-    code: exports.compileFile(path)
-    factoryText: "function(require,exports,module,system,print){ 1 + 1 /**/\n}"
-    if system.engine is "rhino"
-      Packages.org.mozilla.javascript.Context.getCurrentContext().compileFunction(global, factoryText, path, 0, null)
-    else
-      # eval requires parenthesis, but parenthesis break compileFunction.
-      eval("(" + factoryText + ")")..
+  code: exports.compileFile(path)
+  factoryText: "function(require,exports,module,system,print){" + code + "/**/\n}"
+  if system.engine is "rhino"
+    Packages.org.mozilla.javascript.Context.getCurrentContext().compileFunction(global, factoryText, path, 0, null)
+  else
+    # eval requires parentheses, but parentheses break compileFunction.
+    eval("(" + factoryText + ")")

data/lib/coffee_script/narwhal/{js → lib}/coffee-script.js

@@ -1,14 +1,16 @@
 (function(){
   var File, OS, Readline, checkForErrors, coffeePath;
-  // This (javascript) file is generated from lib/coffee_script/narwhal/coffee-script.coffee Executes the `coffee` Ruby program to convert from CoffeeScript
-  // to Javascript. Eventually this will hopefully happen entirely within JS. Require external dependencies.
+  // This (javascript) file is generated from lib/coffee_script/narwhal/coffee-script.coffee
+  // Executes the `coffee` Ruby program to convert from CoffeeScript
+  // to Javascript. Eventually this will hopefully happen entirely within JS.
+  // Require external dependencies.
   OS = require('os');
   File = require('file');
   Readline = require('readline');
   // The path to the CoffeeScript Compiler.
   coffeePath = File.path(module.path).dirname().dirname().dirname().dirname().dirname().join('bin', 'coffee');
   // Our general-purpose error handler.
-  checkForErrors = function(coffeeProcess) {
+  checkForErrors = function checkForErrors(coffeeProcess) {
     if (coffeeProcess.wait() === 0) {
       return true;
     }
@@ -17,17 +19,20 @@
   };
   // Run a simple REPL, round-tripping to the CoffeeScript compiler for every
   // command.
-  exports.run = function(args) {
-    var __a, __b, __c, __d, path, result;
-    args.shift();
+  exports.run = function run(args) {
+    var __a, __b, __c, i, path, result;
     if (args.length) {
       __a = args;
-      __d = [];
-      for (__b=0, __c=__a.length; __b<__c; __b++) {
-        path = __a[__b];
-        __d[__b] = exports.evalCS(File.read(path));
+      __b = [];
+      for (i in __a) {
+        if (__a.hasOwnProperty(i)) {
+          path = __a[i];
+          exports.evalCS(File.read(path));
+          __c = delete args[i];
+          __b.push(__c);
+        }
       }
-      __d;
+      __b;
       return true;
     }
     while (true) {
@@ -43,14 +48,14 @@
     }
   };
   // Compile a given CoffeeScript file into JavaScript.
-  exports.compileFile = function(path) {
+  exports.compileFile = function compileFile(path) {
     var coffee;
     coffee = OS.popen([coffeePath, "--print", "--no-wrap", path]);
     checkForErrors(coffee);
     return coffee.stdout.read();
   };
   // Compile a string of CoffeeScript into JavaScript.
-  exports.compile = function(source) {
+  exports.compile = function compile(source) {
     var coffee;
     coffee = OS.popen([coffeePath, "--eval", "--no-wrap"]);
     coffee.stdin.write(source).flush().close();
@@ -58,18 +63,18 @@
     return coffee.stdout.read();
   };
   // Evaluating a string of CoffeeScript first compiles it externally.
-  exports.evalCS = function(source) {
+  exports.evalCS = function evalCS(source) {
     return eval(exports.compile(source));
   };
   // Make a factory for the CoffeeScript environment.
-  exports.makeNarwhalFactory = function(path) {
+  exports.makeNarwhalFactory = function makeNarwhalFactory(path) {
     var code, factoryText;
     code = exports.compileFile(path);
-    factoryText = "function(require,exports,module,system,print){ 1 + 1 /**/\n}";
+    factoryText = "function(require,exports,module,system,print){" + code + "/**/\n}";
     if (system.engine === "rhino") {
       return Packages.org.mozilla.javascript.Context.getCurrentContext().compileFunction(global, factoryText, path, 0, null);
     } else {
-      // eval requires parenthesis, but parenthesis break compileFunction.
+      // eval requires parentheses, but parentheses break compileFunction.
       return eval("(" + factoryText + ")");
     }
   };

data/lib/coffee_script/narwhal/{js → lib/coffee-script}/loader.js

@@ -6,12 +6,14 @@
   };
   loader = {
     // Reload the coffee-script environment from source.
-    reload: function(topId, path) {
-      coffeescript = coffeescript || require('./coffee-script');
-      return (factories[topId] = coffeescript.makeNarwhalFactory(path));
+    reload: function reload(topId, path) {
+      coffeescript = coffeescript || require('coffee-script');
+      return (factories[topId] = function() {
+        return coffeescript.makeNarwhalFactory(path);
+      });
     },
     // Ensure that the coffee-script environment is loaded.
-    load: function(topId, path) {
+    load: function load(topId, path) {
       return factories[topId] = factories[topId] || this.reload(topId, path);
     }
   };

data/lib/coffee_script/narwhal/loader.coffee

@@ -7,12 +7,12 @@ loader: {
 
   # Reload the coffee-script environment from source.
   reload: topId, path =>
-    coffeescript ||= require('./coffee-script')
-    factories[topId]: coffeescript.makeNarwhalFactory(path).
+    coffeescript ||= require('coffee-script')
+    factories[topId]: => coffeescript.makeNarwhalFactory(path)
 
   # Ensure that the coffee-script environment is loaded.
   load: topId, path =>
-    factories[topId] ||= this.reload(topId, path).
+    factories[topId] ||= this.reload(topId, path)
 
 }
 

data/lib/coffee_script/nodes.rb

@@ -11,17 +11,11 @@ module CoffeeScript
       class_eval "def statement?; true; end"
     end
 
-    # Tag this node as having a custom return, meaning that instead of returning
-    # it from the outside, you ask it to return itself, and it obliges.
-    def self.custom_return
-      class_eval "def custom_return?; true; end"
-    end
-
-    # Tag this node as having a custom assignment, meaning that instead of
-    # assigning it to a variable name from the outside, you pass it the variable
-    # name and let it take care of it.
-    def self.custom_assign
-      class_eval "def custom_assign?; true; end"
+    # Tag this node as a statement that cannot be transformed into an expression.
+    # (break, continue, etc.) It doesn't make sense to try to transform it.
+    def self.statement_only
+      statement
+      class_eval "def statement_only?; true; end"
     end
 
     def write(code)
@@ -29,16 +23,27 @@ module CoffeeScript
       code
     end
 
+    # This is extremely important -- we convert JS statements into expressions
+    # by wrapping them in a closure, only if it's possible, and we're not at
+    # the top level of a block (which would be unnecessary), and we haven't
+    # already been asked to return the result.
     def compile(o={})
       @options = o.dup
+      top = self.is_a?(ForNode) ? @options[:top] : @options.delete(:top)
+      closure = statement? && !statement_only? && !top && !@options[:return]
+      closure ? compile_closure(@options) : compile_node(@options)
+    end
+
+    def compile_closure(o={})
+      indent = o[:indent]
+      o[:indent] += TAB
+      "(function() {\n#{compile_node(o.merge(:return => true))}\n#{indent}})()"
     end
 
     # Default implementations of the common node methods.
-    def unwrap;                                 self;   end
-    def line_ending;                            ';';    end
-    def statement?;                             false;  end
-    def custom_return?;                         false;  end
-    def custom_assign?;                         false;  end
+    def unwrap;           self;   end
+    def statement?;       false;  end
+    def statement_only?;  false;  end
   end
 
   # A collection of nodes, each one representing an expression.
@@ -49,12 +54,13 @@ module CoffeeScript
     STRIP_TRAILING_WHITESPACE = /\s+$/
 
     # Wrap up a node as an Expressions, unless it already is.
-    def self.wrap(node)
-      node.is_a?(Expressions) ? node : Expressions.new([node])
+    def self.wrap(*nodes)
+      return nodes[0] if nodes.length == 1 && nodes[0].is_a?(Expressions)
+      Expressions.new(*nodes)
     end
 
-    def initialize(nodes)
-      @expressions = nodes
+    def initialize(*nodes)
+      @expressions = nodes.flatten
     end
 
     # Tack an expression onto the end of this node.
@@ -63,6 +69,11 @@ module CoffeeScript
       self
     end
 
+    def unshift(node)
+      @expressions.unshift(node)
+      self
+    end
+
     # If this Expressions consists of a single node, pull it back out.
     def unwrap
       @expressions.length == 1 ? @expressions.first : self
@@ -74,47 +85,48 @@ module CoffeeScript
       node == @expressions[@last_index]
     end
 
-    # If this is the top-level Expressions, wrap everything in a safety closure.
-    def root_compile(o={})
-      indent = o[:no_wrap] ? '' : TAB
-      code = compile(o.merge(:indent => indent, :scope => Scope.new), o[:no_wrap] ? nil : :code)
-      code.gsub!(STRIP_TRAILING_WHITESPACE, '')
-      o[:no_wrap] ? code : "(function(){\n#{code}\n})();"
+    def compile(o={})
+      o[:scope] ? super(o) : compile_root(o)
     end
 
-    # The extra fancy is to handle pushing down returns and assignments
-    # recursively to the final lines of inner statements.
-    # Variables first defined within the Expressions body have their
-    # declarations pushed up to the top scope.
-    def compile(options={}, parent=nil)
-      return root_compile(options) unless options[:scope]
+    # The extra fancy is to handle pushing down returns to the final lines of
+    # inner statements. Variables first defined within the Expressions body
+    # have their declarations pushed up top of the closest scope.
+    def compile_node(options={})
       compiled = @expressions.map do |node|
-        o = super(options)
-        if last?(node) && (o[:return] || o[:assign])
-          if o[:return]
-            if node.statement? || node.custom_return?
-              "#{o[:indent]}#{node.compile(o)}#{node.line_ending}"
-            else
-              o.delete(:return)
-              "#{o[:indent]}return #{node.compile(o)}#{node.line_ending}"
-            end
-          elsif o[:assign]
-            if node.statement? || node.custom_assign?
-              "#{o[:indent]}#{node.compile(o)}#{node.line_ending}"
-            else
-              "#{o[:indent]}#{AssignNode.new(o[:assign], node).compile(o)};"
-            end
+        o = options.dup
+        returns = o.delete(:return)
+        if last?(node) && returns && !node.statement_only?
+          if node.statement?
+            node.compile(o.merge(:return => true))
+          else
+            "#{o[:indent]}return #{node.compile(o)};"
           end
         else
-          o.delete(:return) and o.delete(:assign)
-          "#{o[:indent]}#{node.compile(o)}#{node.line_ending}"
+          ending = node.statement? ? '' : ';'
+          indent = node.statement? ? '' : o[:indent]
+          "#{indent}#{node.compile(o.merge(:top => true))}#{ending}"
         end
       end
-      scope = options[:scope]
-      declarations = scope.any_declared? && parent == :code ? "#{options[:indent]}var #{scope.declared_variables.join(', ')};\n" : ''
-      code = declarations + compiled.join("\n")
-      write(code)
+      write(compiled.join("\n"))
+    end
+
+    # If this is the top-level Expressions, wrap everything in a safety closure.
+    def compile_root(o={})
+      indent = o[:no_wrap] ? '' : TAB
+      o.merge!(:indent => indent, :scope => Scope.new(nil, self))
+      code = o[:no_wrap] ? compile_node(o) : compile_with_declarations(o)
+      code.gsub!(STRIP_TRAILING_WHITESPACE, '')
+      o[:no_wrap] ? code : "(function(){\n#{code}\n})();"
+    end
+
+    def compile_with_declarations(o={})
+      code  = compile_node(o)
+      decls = ''
+      decls = "#{o[:indent]}var #{o[:scope].declared_variables.join(', ')};\n" if o[:scope].declarations?(self)
+      decls + code
     end
+
   end
 
   # Literals are static values that have a Ruby representation, eg.: a string, a number,
@@ -131,21 +143,18 @@ module CoffeeScript
     def statement?
       STATEMENTS.include?(@value.to_s)
     end
+    alias_method :statement_only?, :statement?
 
-    def line_ending
-      @value.to_s[-1..-1] == ';' ? '' : ';'
-    end
-
-    def compile(o={})
-      o = super(o)
-      write(@value.to_s)
+    def compile_node(o)
+      indent = statement? ? o[:indent] : ''
+      ending = statement? ? ';' : ''
+      write(indent + @value.to_s + ending)
     end
   end
 
   # Try to return your expression, or tell it to return itself.
   class ReturnNode < Node
-    statement
-    custom_return
+    statement_only
 
     attr_reader :expression
 
@@ -153,32 +162,23 @@ module CoffeeScript
       @expression = expression
     end
 
-    def line_ending
-      @expression.custom_return? ? '' : ';'
-    end
-
-    def compile(o={})
-      o = super(o)
-      return write(@expression.compile(o.merge(:return => true))) if @expression.custom_return?
+    def compile_node(o)
+      return write(@expression.compile(o.merge(:return => true))) if @expression.statement?
       compiled = @expression.compile(o)
-      write(@expression.statement? ? "#{compiled}\n#{indent}return null" : "return #{compiled}")
+      write(@expression.statement? ? "#{compiled}\n#{o[:indent]}return null;" : "#{o[:indent]}return #{compiled};")
     end
   end
 
   # Pass through CoffeeScript comments into JavaScript comments at the
   # same position.
   class CommentNode < Node
-    statement
+    statement_only
 
     def initialize(lines)
       @lines = lines.value
     end
 
-    def line_ending
-      ''
-    end
-
-    def compile(o={})
+    def compile_node(o={})
       delimiter = "\n#{o[:indent]}//"
       comment   = "#{delimiter}#{@lines.join(delimiter)}"
       write(comment)
@@ -189,8 +189,6 @@ module CoffeeScript
   # Node for a function invocation. Takes care of converting super() calls into
   # calls against the prototype's function of the same name.
   class CallNode < Node
-    LEADING_DOT = /\A\./
-
     attr_reader :variable, :arguments
 
     def initialize(variable, arguments=[])
@@ -206,42 +204,65 @@ module CoffeeScript
       @variable == :super
     end
 
-    def compile(o={})
-      o = super(o)
+    def prefix
+      @new ? "new " : ''
+    end
+
+    def splat?
+      @arguments.any? {|a| a.is_a?(ArgSplatNode) }
+    end
+
+    def <<(argument)
+      @arguments << argument
+    end
+
+    def compile_node(o)
+      return write(compile_splat(o)) if splat?
       args = @arguments.map{|a| a.compile(o) }.join(', ')
       return write(compile_super(args, o)) if super?
-      prefix = @new ? "new " : ''
       write("#{prefix}#{@variable.compile(o)}(#{args})")
     end
 
     def compile_super(args, o)
-      methname = o[:last_assign].sub(LEADING_DOT, '')
+      methname = o[:last_assign]
       arg_part = args.empty? ? '' : ", #{args}"
       "#{o[:proto_assign]}.__superClass__.#{methname}.call(this#{arg_part})"
     end
+
+    def compile_splat(o)
+      meth = @variable.compile(o)
+      obj  = @variable.source || 'this'
+      args = @arguments.map do |arg|
+        code = arg.compile(o)
+        code = arg.is_a?(ArgSplatNode) ? code : "[#{code}]"
+        arg.equal?(@arguments.first) ? code : ".concat(#{code})"
+      end
+      "#{prefix}#{meth}.apply(#{obj}, #{args.join('')})"
+    end
   end
 
   # Node to extend an object's prototype with an ancestor object.
   # After goog.inherits from the Closure Library.
   class ExtendsNode < Node
+    statement
     attr_reader :sub_object, :super_object
 
     def initialize(sub_object, super_object)
       @sub_object, @super_object = sub_object, super_object
     end
 
-    def compile(o={})
+    def compile_node(o={})
       sub, sup = @sub_object.compile(o), @super_object.compile(o)
-      "#{sub}.__superClass__ = #{sup}.prototype;\n#{o[:indent]}" +
+      "#{o[:indent]}#{sub}.__superClass__ = #{sup}.prototype;\n#{o[:indent]}" +
       "#{sub}.prototype = new #{sup}();\n#{o[:indent]}" +
-      "#{sub}.prototype.constructor = #{sub}"
+      "#{sub}.prototype.constructor = #{sub};"
     end
 
   end
 
   # A value, indexed or dotted into, or vanilla.
   class ValueNode < Node
-    attr_reader :literal, :properties, :last
+    attr_reader :literal, :properties, :last, :source
 
     def initialize(literal, properties=[])
       @literal, @properties = literal, properties
@@ -260,20 +281,14 @@ module CoffeeScript
       @literal.is_a?(Node) && @literal.statement? && !properties?
     end
 
-    def custom_assign?
-      @literal.is_a?(Node) && @literal.custom_assign? && !properties?
-    end
-
-    def custom_return?
-      @literal.is_a?(Node) && @literal.custom_return? && !properties?
-    end
-
-    def compile(o={})
-      o = super(o)
-      parts = [@literal, @properties].flatten.map do |val|
+    def compile_node(o)
+      only  = o.delete(:only_first)
+      props = only ? @properties[0...-1] : @properties
+      parts = [@literal, props].flatten.map do |val|
         val.respond_to?(:compile) ? val.compile(o) : val.to_s
       end
       @last = parts.last
+      @source = parts.length > 1 ? parts[0...-1].join('') : nil
       write(parts.join(''))
     end
   end
@@ -286,8 +301,7 @@ module CoffeeScript
       @name = name
     end
 
-    def compile(o={})
-      o = super(o)
+    def compile_node(o)
       write(".#{@name}")
     end
   end
@@ -300,15 +314,14 @@ module CoffeeScript
       @index = index
     end
 
-    def compile(o={})
-      o = super(o)
+    def compile_node(o)
       write("[#{@index.compile(o)}]")
     end
   end
 
   # A range literal. Ranges can be used to extract portions (slices) of arrays,
   # or to specify a range for array comprehensions.
-  class RangeNode
+  class RangeNode < Node
     attr_reader :from, :to
 
     def initialize(from, to, exclusive=false)
@@ -327,12 +340,21 @@ module CoffeeScript
       @exclusive ? '>' : '>='
     end
 
-    def compile(o, fv, tv)
-      fvv, tvv = @from.compile(o), @to.compile(o)
-      vars     = "#{fv}=#{fvv}, #{tv}=#{tvv}"
-      compare  = "(#{fvv} <= #{tvv} ? #{fv} #{less_operator} #{tv} : #{fv} #{greater_operator} #{tv})"
-      incr     = "(#{fvv} <= #{tvv} ? #{fv} += 1 : #{fv} -= 1)"
-      "#{vars}; #{compare}; #{incr}"
+    def compile_variables(o)
+      idt = o[:indent]
+      @from_var, @to_var = o[:scope].free_variable, o[:scope].free_variable
+      from_val,  to_val  = @from.compile(o), @to.compile(o)
+      write("#{idt}#{@from_var} = #{from_val};\n#{idt}#{@to_var} = #{to_val};\n#{idt}")
+    end
+
+    def compile_node(o)
+      idx, step = o.delete(:index), o.delete(:step)
+      raise SyntaxError, "unexpected range literal" unless idx
+      vars     = "#{idx}=#{@from_var}"
+      step     = step ? step.compile(o) : '1'
+      compare  = "(#{@from_var} <= #{@to_var} ? #{idx} #{less_operator} #{@to_var} : #{idx} #{greater_operator} #{@to_var})"
+      incr     = "(#{@from_var} <= #{@to_var} ? #{idx} += #{step} : #{idx} -= #{step})"
+      write("#{vars}; #{compare}; #{incr}")
     end
 
   end
@@ -347,8 +369,7 @@ module CoffeeScript
       @range = range
     end
 
-    def compile(o={})
-      o         = super(o)
+    def compile_node(o)
       from      = @range.from.compile(o)
       to        = @range.to.compile(o)
       plus_part = @range.exclusive? ? '' : ' + 1'
@@ -359,8 +380,7 @@ module CoffeeScript
   # Setting the value of a local variable, or the value of an object property.
   class AssignNode < Node
     PROTO_ASSIGN = /\A(\S+)\.prototype/
-
-    custom_return
+    LEADING_DOT = /\A\./
 
     attr_reader :variable, :value, :context
 
@@ -368,21 +388,26 @@ module CoffeeScript
       @variable, @value, @context = variable, value, context
     end
 
-    def line_ending
-      @value.custom_assign? ? '' : ';'
-    end
-
-    def compile(o={})
-      o = super(o)
+    def compile_node(o)
+      return compile_splice(o) if @variable.properties.last.is_a?(SliceNode)
       name      = @variable.compile(o)
-      last      = @variable.last.to_s
+      last      = @variable.last.to_s.sub(LEADING_DOT, '')
       proto     = name[PROTO_ASSIGN, 1]
-      o         = o.merge(:assign => @variable, :last_assign => last, :proto_assign => proto)
+      o         = o.merge(:last_assign => last, :proto_assign => proto)
+      o[:immediate_assign] = last if @value.is_a?(CodeNode) && last.match(Lexer::IDENTIFIER)
       return write("#{name}: #{@value.compile(o)}") if @context == :object
       o[:scope].find(name) unless @variable.properties?
-      return write(@value.compile(o)) if @value.custom_assign?
       val = "#{name} = #{@value.compile(o)}"
-      write(o[:return] && !@value.custom_return? ? "return (#{val})" : val)
+      write(o[:return] ? "#{o[:indent]}return (#{val})" : val)
+    end
+
+    def compile_splice(o)
+      var   = @variable.compile(o.merge(:only_first => true))
+      range = @variable.properties.last.range
+      plus  = range.exclusive? ? '' : ' + 1'
+      from  = range.from.compile(o)
+      to    = "#{range.to.compile(o)} - #{from}#{plus}"
+      write("#{var}.splice.apply(#{var}, [#{from}, #{to}].concat(#{@value.compile(o)}))")
     end
   end
 
@@ -390,31 +415,30 @@ module CoffeeScript
   # CoffeeScript operations into their JavaScript equivalents.
   class OpNode < Node
     CONVERSIONS = {
-      "=="    => "===",
-      "!="    => "!==",
-      'and'   => '&&',
-      'or'    => '||',
-      'is'    => '===',
-      "isnt"  => "!==",
-      'not'   => '!'
+      :==     => "===",
+      :'!='   => "!==",
+      :and    => '&&',
+      :or     => '||',
+      :is     => '===',
+      :isnt   => "!==",
+      :not    => '!'
     }
-    CONDITIONALS     = ['||=', '&&=']
-    PREFIX_OPERATORS = ['typeof', 'delete']
+    CONDITIONALS     = [:'||=', :'&&=']
+    PREFIX_OPERATORS = [:typeof, :delete]
 
     attr_reader :operator, :first, :second
 
     def initialize(operator, first, second=nil, flip=false)
       @first, @second, @flip = first, second, flip
-      @operator = CONVERSIONS[operator] || operator
+      @operator = CONVERSIONS[operator.to_sym] || operator
     end
 
     def unary?
       @second.nil?
     end
 
-    def compile(o={})
-      o = super(o)
-      return write(compile_conditional(o)) if CONDITIONALS.include?(@operator)
+    def compile_node(o)
+      return write(compile_conditional(o)) if CONDITIONALS.include?(@operator.to_sym)
       return write(compile_unary(o)) if unary?
       write("#{@first.compile(o)} #{@operator} #{@second.compile(o)}")
     end
@@ -426,7 +450,7 @@ module CoffeeScript
     end
 
     def compile_unary(o)
-      space = PREFIX_OPERATORS.include?(@operator.to_s) ? ' ' : ''
+      space = PREFIX_OPERATORS.include?(@operator.to_sym) ? ' ' : ''
       parts = [@operator.to_s, space, @first.compile(o)]
       parts.reverse! if @flip
       parts.join('')
@@ -442,18 +466,53 @@ module CoffeeScript
       @body = body
     end
 
-    def compile(o={})
-      o = super(o)
-      o[:scope] = Scope.new(o[:scope])
-      o[:return] = true
-      indent = o[:indent]
-      o[:indent] += TAB
-      o.delete(:assign)
+    def compile_node(o)
+      shared_scope = o.delete(:shared_scope)
+      indent       = o[:indent]
+      o[:scope]    = shared_scope || Scope.new(o[:scope], @body)
+      o[:return]   = true
+      o[:top]      = true
+      o[:indent]  += TAB
       o.delete(:no_wrap)
+      name = o.delete(:immediate_assign)
+      if @params.last.is_a?(ParamSplatNode)
+        splat = @params.pop
+        splat.index = @params.length
+        @body.unshift(splat)
+      end
       @params.each {|id| o[:scope].parameter(id.to_s) }
-      code = @body.compile(o, :code)
-      write("function(#{@params.join(', ')}) {\n#{code}\n#{indent}}")
+      code = @body.compile_with_declarations(o)
+      name_part = name ? " #{name}" : ''
+      write("function#{name_part}(#{@params.join(', ')}) {\n#{code}\n#{indent}}")
+    end
+  end
+
+  # A parameter splat in a function definition.
+  class ParamSplatNode < Node
+    attr_accessor :index
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def compile_node(o={})
+      o[:scope].find(@name)
+      write("#{@name} = Array.prototype.slice.call(arguments, #{@index})")
+    end
+  end
+
+  class ArgSplatNode < Node
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def compile_node(o={})
+      write(@value.compile(o))
     end
+
   end
 
   # An object literal.
@@ -464,13 +523,20 @@ module CoffeeScript
       @properties = properties
     end
 
-    def compile(o={})
-      o = super(o)
+    # All the mucking about with commas is to make sure that CommentNodes and
+    # AssignNodes get interleaved correctly, with no trailing commas or
+    # commas affixed to comments. TODO: Extract this and add it to ArrayNode.
+    def compile_node(o)
       indent = o[:indent]
       o[:indent] += TAB
-      props = @properties.map { |prop|
-        joiner = prop == @properties.last ? '' : prop.is_a?(CommentNode) ? "\n" : ",\n"
-        o[:indent] + prop.compile(o) + joiner
+      joins = Hash.new("\n")
+      non_comments = @properties.select {|p| !p.is_a?(CommentNode) }
+      non_comments.each {|p| joins[p] = p == non_comments.last ? "\n" : ",\n" }
+      props  = @properties.map { |prop|
+        join = joins[prop]
+        join = '' if prop == @properties.last
+        idt  = prop.is_a?(CommentNode) ? '' : o[:indent]
+        "#{idt}#{prop.compile(o)}#{join}"
       }.join('')
       write("{\n#{props}\n#{indent}}")
     end
@@ -484,13 +550,15 @@ module CoffeeScript
       @objects = objects
     end
 
-    def compile(o={})
-      o = super(o)
+    def compile_node(o)
+      indent = o[:indent]
+      o[:indent] += TAB
       objects = @objects.map { |obj|
-        joiner = obj.is_a?(CommentNode) ? "\n#{o[:indent] + TAB}" : obj == @objects.last ? '' : ', '
-        obj.compile(o.merge(:indent => o[:indent] + TAB)) + joiner
+        code = obj.compile(o)
+        obj.is_a?(CommentNode) ? "\n#{code}\n#{o[:indent]}" :
+        obj == @objects.last   ? code : "#{code}, "
       }.join('')
-      ending = objects.include?("\n") ? "\n#{o[:indent]}]" : ']'
+      ending = objects.include?("\n") ? "\n#{indent}]" : ']'
       write("[#{objects}#{ending}")
     end
   end
@@ -506,16 +574,14 @@ module CoffeeScript
       @condition, @body = condition, body
     end
 
-    def line_ending
-      ''
-    end
-
-    def compile(o={})
-      o = super(o)
-      o.delete(:return)
-      indent = o[:indent] + TAB
-      cond = @condition.compile(o)
-      write("while (#{cond}) {\n#{@body.compile(o.merge(:indent => indent))}\n#{o[:indent]}}")
+    def compile_node(o)
+      returns     = o.delete(:return)
+      indent      = o[:indent]
+      o[:indent] += TAB
+      o[:top]     = true
+      cond        = @condition.compile(o)
+      post        = returns ? "\n#{indent}return null;" : ''
+      write("#{indent}while (#{cond}) {\n#{@body.compile(o)}\n#{indent}}#{post}")
     end
   end
 
@@ -525,74 +591,70 @@ module CoffeeScript
   # the current index of the loop as a second parameter.
   class ForNode < Node
     statement
-    custom_return
-    custom_assign
-
-    attr_reader :body, :source, :name, :filter, :index
 
-    def initialize(body, source, name, filter, index=nil)
-      @body, @source, @name, @filter, @index = body, source, name, filter, index
-    end
+    attr_reader :body, :source, :name, :index, :filter, :step
 
-    def line_ending
-      ''
+    def initialize(body, source, name, index=nil)
+      @body, @name, @index = body, name, index
+      @source = source[:source]
+      @filter = source[:filter]
+      @step   = source[:step]
     end
 
-    def compile(o={})
-      o = super(o)
+    def compile_node(o)
+      top_level     = o.delete(:top) && !o[:return]
       range         = @source.is_a?(RangeNode)
       scope         = o[:scope]
       name_found    = scope.find(@name)
       index_found   = @index && scope.find(@index)
       svar          = scope.free_variable
-      ivar          = range ? name : scope.free_variable
-      lvar          = scope.free_variable
-      rvar          = scope.free_variable
-      index_name    = @index ? @index : nil
+      ivar          = range ? name : @index ? @index : scope.free_variable
+      rvar          = scope.free_variable unless top_level
+      tvar          = scope.free_variable
       if range
-        source_part = ''
-        var_part    = ''
-        index_part  = ''
+        body_dent   = o[:indent] + TAB
+        var_part, pre_cond, post_cond = '', '', ''
         index_var   = scope.free_variable
-        for_part    = "#{index_var}=0, #{@source.compile(o, ivar, lvar)}, #{index_var}++"
+        source_part = @source.compile_variables(o)
+        for_part    = "#{index_var}=0, #{@source.compile(o.merge(:index => ivar, :step => @step))}, #{index_var}++"
       else
         index_var   = nil
-        source_part = "#{svar} = #{@source.compile(o)};\n#{o[:indent]}"
-        for_part    = "#{ivar}=0, #{lvar}=#{svar}.length; #{ivar}<#{lvar}; #{ivar}++"
-        var_part    = "\n#{o[:indent] + TAB}#{@name} = #{svar}[#{ivar}];"
-        index_part  = @index ? "\n#{o[:indent] + TAB}#{index_name} = #{ivar};" : ''
+        body_dent   = o[:indent] + TAB + TAB
+        source_part = "#{o[:indent]}#{svar} = #{@source.compile(o)};\n#{o[:indent]}"
+        for_part    = "#{ivar} in #{svar}"
+        pre_cond    = "\n#{o[:indent] + TAB}if (#{svar}.hasOwnProperty(#{ivar})) {"
+        var_part    = "\n#{body_dent}#{@name} = #{svar}[#{ivar}];"
+        post_cond   = "\n#{o[:indent] + TAB}}"
       end
       body          = @body
-      suffix        = ';'
-      set_result    = "#{rvar} = [];\n#{o[:indent]}"
-      save_result   = "#{rvar}[#{index_var || ivar}] = "
-      return_result = rvar
-
-      if o[:return] || o[:assign]
-        return_result = "#{o[:assign].compile(o)} = #{return_result}" if o[:assign]
+      set_result    = rvar ? "#{rvar} = [];\n#{o[:indent]}" : ''
+      return_result = rvar || ''
+      temp_var      = ValueNode.new(LiteralNode.new(tvar))
+      if top_level
+        body = Expressions.wrap(body)
+      else
+        body = Expressions.wrap(
+          AssignNode.new(temp_var, @body.unwrap),
+          CallNode.new(ValueNode.new(LiteralNode.new(rvar), [AccessorNode.new('push')]), [temp_var])
+        )
+      end
+      if o[:return]
         return_result = "return #{return_result}" if o[:return]
-        if @filter
-          body = CallNode.new(ValueNode.new(LiteralNode.new(rvar), [AccessorNode.new('push')]), [@body])
-          body = IfNode.new(@filter, body, nil, :statement => true)
-          save_result = ''
-          suffix = ''
-        end
+        o.delete(:return)
+        body = IfNode.new(@filter, body, nil, :statement => true) if @filter
       elsif @filter
-        body = IfNode.new(@filter, @body)
+        body = Expressions.wrap(IfNode.new(@filter, @body))
       end
 
-      return_result = "\n#{o[:indent]}#{return_result};"
-      indent = o[:indent] + TAB
-      body = body.compile(o.merge(:indent => indent))
-      write("#{source_part}#{set_result}for (#{for_part}) {#{var_part}#{index_part}\n#{indent}#{save_result}#{body}#{suffix}\n#{o[:indent]}}#{return_result}")
+      return_result = "\n#{o[:indent]}#{return_result};" unless top_level
+      body = body.compile(o.merge(:indent => body_dent, :top => true))
+      write("#{source_part}#{set_result}for (#{for_part}) {#{pre_cond}#{var_part}\n#{body}#{post_cond}\n#{o[:indent]}}#{return_result}")
     end
   end
 
   # A try/catch/finally block.
   class TryNode < Node
     statement
-    custom_return
-    custom_assign
 
     attr_reader :try, :error, :recovery, :finally
 
@@ -600,24 +662,20 @@ module CoffeeScript
       @try, @error, @recovery, @finally = try, error, recovery, finally
     end
 
-    def line_ending
-      ''
-    end
-
-    def compile(o={})
-      o = super(o)
+    def compile_node(o)
       indent = o[:indent]
       o[:indent] += TAB
+      o[:top] = true
       error_part = @error ? " (#{@error}) " : ' '
       catch_part = @recovery &&  " catch#{error_part}{\n#{@recovery.compile(o)}\n#{indent}}"
-      finally_part = @finally && " finally {\n#{@finally.compile(o.merge(:assign => nil, :return => nil))}\n#{indent}}"
-      write("try {\n#{@try.compile(o)}\n#{indent}}#{catch_part}#{finally_part}")
+      finally_part = @finally && " finally {\n#{@finally.compile(o.merge(:return => nil))}\n#{indent}}"
+      write("#{indent}try {\n#{@try.compile(o)}\n#{indent}}#{catch_part}#{finally_part}")
     end
   end
 
   # Throw an exception.
   class ThrowNode < Node
-    statement
+    statement_only
 
     attr_reader :expression
 
@@ -625,9 +683,22 @@ module CoffeeScript
       @expression = expression
     end
 
-    def compile(o={})
-      o = super(o)
-      write("throw #{@expression.compile(o)}")
+    def compile_node(o)
+      write("#{o[:indent]}throw #{@expression.compile(o)};")
+    end
+  end
+
+  # Check an expression for existence (meaning not null or undefined).
+  class ExistenceNode < Node
+    attr_reader :expression
+
+    def initialize(expression)
+      @expression = expression
+    end
+
+    def compile_node(o)
+      val = @expression.compile(o)
+      write("(typeof #{val} !== \"undefined\" && #{val} !== null)")
     end
   end
 
@@ -637,25 +708,12 @@ module CoffeeScript
   class ParentheticalNode < Node
     attr_reader :expressions
 
-    def initialize(expressions)
+    def initialize(expressions, line=nil)
       @expressions = expressions.unwrap
+      @line = line
     end
 
-    def statement?
-      @expressions.unwrap.statement?
-    end
-
-    def custom_assign?
-      @expressions.custom_assign?
-    end
-
-    def custom_return?
-      @expressions.custom_return?
-    end
-
-    def compile(o={})
-      raise SyntaxError, "parentheses can't be wrapped around a statement" if statement?
-      o = super(o)
+    def compile_node(o)
       compiled = @expressions.compile(o)
       compiled = compiled[0...-1] if compiled[-1..-1] == ';'
       write("(#{compiled})")
@@ -683,6 +741,11 @@ module CoffeeScript
       self
     end
 
+    def force_statement
+      @tags[:statement] = true
+      self
+    end
+
     # Rewrite a chain of IfNodes with their switch condition for equality.
     def rewrite_condition(expression)
       @condition = OpNode.new("is", expression, @condition)
@@ -691,8 +754,8 @@ module CoffeeScript
     end
 
     # Rewrite a chain of IfNodes to add a default case as the final else.
-    def add_else(expressions)
-      chain? ? @else_body.add_else(expressions) : @else_body = expressions
+    def add_else(exprs)
+      chain? ? @else_body.add_else(exprs) : @else_body = (exprs && exprs.unwrap)
       self
     end
 
@@ -707,20 +770,7 @@ module CoffeeScript
       @is_statement ||= !!(@tags[:statement] || @body.statement? || (@else_body && @else_body.statement?))
     end
 
-    def custom_return?
-      statement?
-    end
-
-    def custom_assign?
-      statement?
-    end
-
-    def line_ending
-      statement? ? '' : ';'
-    end
-
-    def compile(o={})
-      o = super(o)
+    def compile_node(o)
       write(statement? ? compile_statement(o) : compile_ternary(o))
     end
 
@@ -728,14 +778,16 @@ module CoffeeScript
     # force sub-else bodies into statement form.
     def compile_statement(o)
       indent = o[:indent]
+      child  = o.delete(:chain_child)
       cond_o = o.dup
-      cond_o.delete(:assign)
       cond_o.delete(:return)
       o[:indent] += TAB
-      if_part   = "if (#{@condition.compile(cond_o)}) {\n#{Expressions.wrap(@body).compile(o)}\n#{indent}}"
+      o[:top] = true
+      if_dent = child ? '' : indent
+      if_part = "#{if_dent}if (#{@condition.compile(cond_o)}) {\n#{Expressions.wrap(@body).compile(o)}\n#{indent}}"
       return if_part unless @else_body
       else_part = chain? ?
-        " else #{@else_body.compile(o.merge(:indent => indent))}" :
+        " else #{@else_body.compile(o.merge(:indent => indent, :chain_child => true))}" :
         " else {\n#{Expressions.wrap(@else_body).compile(o)}\n#{indent}}"
       if_part + else_part
     end