Coffee Tags

src/lexer.coffee

@@ -66,6 +66,7 @@ exports.Lexer = class Lexer
            @numberToken()     or
            @regexToken()      or
            @jsToken()         or
+           @ctToken()         or
            @literalToken()
 
       # Update position
@@ -235,12 +236,13 @@ exports.Lexer = class Lexer
       when '"'   then STRING_DOUBLE
       when "'''" then HEREDOC_SINGLE
       when '"""' then HEREDOC_DOUBLE
+      when '<*>' then HERETAG_DOUBLE
     heredoc = quote.length is 3
 
     {tokens, index: end} = @matchWithInterpolations regex, quote
     $ = tokens.length - 1
 
-    delimiter = quote.charAt(0)
+    delimiter = if quote.charAt(0) is '<' then '"' else quote.charAt(0)
     if heredoc
       # Find the smallest indentation. It will be removed from all lines later.
       indent = null
@@ -287,6 +289,12 @@ exports.Lexer = class Lexer
     @token 'JS', (script = match[0])[1...-1], 0, script.length
     script.length
 
+  # Matches CoffeeTags.
+  ctToken:  ->
+    return 0 unless @chunk.charAt(0) is '<' and match = CTTOKEN.exec @chunk
+    @token 'CT', (ct = match[0])[1...-1], 0, ct.length
+    ct.length
+
   # Matches regular expression literals, as well as multiline extended ones.
   # Lexing regular expressions is difficult to distinguish from division, so we
   # borrow some basic heuristics from JavaScript and Ruby.
@@ -883,13 +891,17 @@ MULTI_DENT = /^(?:\n[^\n\S]*)+/
 
 JSTOKEN    = /^`[^\\`]*(?:\\.[^\\`]*)*`/
 
+# CoffeeTags loosely matches <tag.class1.class2@id>
+CTTOKEN    = /^<[\w\-.@]*[!?]?>/
+
 # String-matching-regexes.
-STRING_START   = /^(?:'''|"""|'|")/
+STRING_START   = /^(?:'''|"""|'|"|<\*>)/
 
 STRING_SINGLE  = /// ^(?: [^\\']  | \\[\s\S]                      )* ///
 STRING_DOUBLE  = /// ^(?: [^\\"#] | \\[\s\S] |           \#(?!\{) )* ///
 HEREDOC_SINGLE = /// ^(?: [^\\']  | \\[\s\S] | '(?!'')            )* ///
 HEREDOC_DOUBLE = /// ^(?: [^\\"#] | \\[\s\S] | "(?!"") | \#(?!\{) )* ///
+HERETAG_DOUBLE = /// ^(?: [^\\<#] | \\[\s\S] | <(?!\*>)| \#(?!\{) )* ///
 
 STRING_OMIT    = ///
     ((?:\\\\)+)      # consume (and preserve) an even number of backslashes

src/rewriter.coffee

@@ -31,6 +31,7 @@ class exports.Rewriter
     @closeOpenIndexes()
     @normalizeLines()
     @tagPostfixConditionals()
+    @adjustCoffeeTags()
     @addImplicitBracesAndParens()
     @addLocationDataToGeneratedTokens()
     @tokens
@@ -117,6 +118,15 @@ class exports.Rewriter
       return yes if @tag(end + 1) is ':'
     no
 
+  # Returns `yes` if standing in front of something that can be
+  # implicitly appended to the prior line with a comma.
+  looksAppendable: (j, stack) ->
+    if (@looksObjectish(j) or @indexOfTag(j, IMPLICIT_CALL) > -1)
+      return not @findTagsBackwards(j - 2, ['CLASS', 'EXTENDS', 'IF',
+        ':', 'FINALLY', # should we also add 'TRY'?
+        'CATCH', 'SWITCH', 'LEADING_WHEN', 'FOR', 'WHILE', 'UNTIL'])
+    no
+
   # Returns `yes` if current line of tokens contain an element of tags on same
   # expression level. Stop searching at LINEBREAKS or explicit start of
   # containing balanced expression.
@@ -131,6 +141,18 @@ class exports.Rewriter
       i -= 1
     @tag(i) in tags
 
+  # Adjust token stream so that CoffeeTags look like normal function calls.
+  adjustCoffeeTags: ->
+    @scanTokens (token, i, tokens) ->
+      if token[0] is 'CT'
+        f = generate 'IDENTIFIER', 'h'; f.spaced = true
+        s = generate 'STRING', "'#{token[1]}'"
+        c = generate ',', ',' if tokens[i + 1][0] isnt 'TERMINATOR'
+        tokens.splice i + 0, 1, f, s
+        tokens.splice i + 2, 0, c if c
+        return if c then 3 else 2
+      return 1
+
   # Look for signs of implicit calls and objects in the token stream and
   # add them.
   addImplicitBracesAndParens: ->
@@ -194,8 +216,13 @@ class exports.Rewriter
         #
         #  1. We have seen a `CONTROL` argument on the line.
         #  2. The last token before the indent is part of the list below
+        #  3. We are able to add this token to the prior line with a comma
         #
         if prevTag not in ['=>', '->', '[', '(', ',', '{', 'TRY', 'ELSE', '=']
+          if @looksAppendable(i + 1, stack)
+            tokens.splice i, 0, generate ',', ',' # insert comma before indent
+            stack.push [tag, i]
+            return forward(2)
           endImplicitCall() while inImplicitCall()
         stack.pop() if inImplicitControl()
         stack.push [tag, i]
@@ -242,7 +269,7 @@ class exports.Rewriter
       #       b: c
       #
       # Don't accept implicit calls of this type, when on the same line
-      # as the control strucutures below as that may misinterpret constructs like:
+      # as the control structures below as that may misinterpret constructs like:
       #
       #     if f
       #        a: 1