fix: implement mappers for interpolated strings and heregexes

src/mappers/mapCall.ts

@@ -1,5 +1,5 @@
 import SourceType from 'coffee-lex/dist/SourceType';
-import { Call, Splat } from 'decaffeinate-coffeescript/lib/coffee-script/nodes';
+import { Call, Literal, Parens, Splat, Value } from 'decaffeinate-coffeescript/lib/coffee-script/nodes';
 import { inspect } from 'util';
 import {
   AssignOp,
@@ -8,7 +8,9 @@ import {
 } from '../nodes';
 import isHeregexTemplateNode from '../util/isHeregexTemplateNode';
 import locationsEqual from '../util/locationsEqual';
+import makeHeregex from '../util/makeHeregex';
 import ParseContext from '../util/ParseContext';
+import parseString from '../util/parseString';
 import mapAny from './mapAny';
 import { UnsupportedNodeError } from './mapAnyWithFallback';
 import mapBase from './mapBase';
@@ -17,7 +19,22 @@ export default function mapCall(context: ParseContext, node: Call): Node {
   let { line, column, start, end, raw } = mapBase(context, node);
 
   if (isHeregexTemplateNode(node, context)) {
-    throw new UnsupportedNodeError(node);
+    let firstArg = node.args[0];
+    if (!(firstArg instanceof Value) || !(firstArg.base instanceof Parens)) {
+      throw new Error('Expected a valid first heregex arg in the AST.');
+    }
+    let strNode = firstArg.base.body.expressions[0];
+    let flags;
+    if (node.args.length > 1) {
+      let secondArg = node.args[1];
+      if (!(secondArg instanceof Value) || !(secondArg.base instanceof Literal)) {
+        throw new Error('Expected a string flags value in the heregex AST.');
+      }
+      flags = parseString(secondArg.base.value);
+    } else {
+      flags = '';
+    }
+    return makeHeregex(context, strNode, flags);
   }
 
   let args = node.args.map(arg => mapAny(context, arg));

src/mappers/mapOp.ts

@@ -4,12 +4,14 @@ import { inspect } from 'util';
 import {
   BinaryOp, BitAndOp, BitNotOp, BitOrOp, BitXorOp, ChainedComparisonOp, DeleteOp, DivideOp, ExpOp, EQOp, GTEOp, GTOp,
   InstanceofOp, LeftShiftOp, LogicalAndOp, LogicalNotOp, LogicalOrOp, LTEOp, LTOp, ModuloOp, MultiplyOp, NewOp, Node,
-  NEQOp, OfOp, Op, OperatorInfo, PostDecrementOp, PostIncrementOp, PreDecrementOp, PreIncrementOp, RemOp,
-  SignedRightShiftOp, SubtractOp, TypeofOp, UnaryNegateOp, UnaryOp, UnaryPlusOp, UnsignedRightShiftOp, Yield, YieldFrom,
-  YieldReturn
+  NEQOp, OfOp, Op, OperatorInfo, PlusOp, PostDecrementOp, PostIncrementOp, PreDecrementOp, PreIncrementOp,
+  RemOp, SignedRightShiftOp, SubtractOp, TypeofOp, UnaryNegateOp, UnaryOp, UnaryPlusOp, UnsignedRightShiftOp, Yield,
+  YieldFrom, YieldReturn
 } from '../nodes';
 import getOperatorInfoInRange from '../util/getOperatorInfoInRange';
 import isChainedComparison from '../util/isChainedComparison';
+import isImplicitPlusOp from '../util/isImplicitPlusOp';
+import makeString from '../util/makeString';
 import ParseContext from '../util/ParseContext';
 import unwindChainedComparison from '../util/unwindChainedComparison';
 import mapAny from './mapAny';
@@ -150,12 +152,14 @@ function mapOpWithoutChainedComparison(context: ParseContext, node: CoffeeOp): N
   throw new UnsupportedNodeError(node);
 }
 
-function mapPlusOp(context: ParseContext, node: CoffeeOp): Op {
+function mapPlusOp(context: ParseContext, node: CoffeeOp): Node {
   if (node.second) {
-    // TODO: string interpolations and binary addition
-    throw new UnsupportedNodeError(node);
+    if (isImplicitPlusOp(node, context)) {
+      return makeString(context, node);
+    } else {
+      return mapBinaryOp(context, node, PlusOp);
+    }
   }
-
   return mapUnaryOp(context, node, UnaryPlusOp);
 }
 

src/parser.js

@@ -6,7 +6,6 @@ import unwindChainedComparison from './util/unwindChainedComparison';
 import getOperatorInfoInRange from './util/getOperatorInfoInRange';
 import isHeregexTemplateNode from './util/isHeregexTemplateNode';
 import isImplicitPlusOp from './util/isImplicitPlusOp';
-import isInterpolatedString from './util/isInterpolatedString';
 import fixInvalidLocationData from './util/fixInvalidLocationData';
 import lex, { SourceType } from 'coffee-lex';
 import locationsEqual from './util/locationsEqual';
@@ -400,7 +399,7 @@ function convert(context: ParseContext, map: (context: ParseContext, node: Base,
 
       case 'Op': {
         return map(context, node, () => {
-          if (isImplicitPlusOp(node, context) && isInterpolatedString(node, ancestors, context)) {
+          if (isImplicitPlusOp(node, context)) {
             let { quasis, unmappedExpressions, start, end } = getTemplateLiteralComponents(context, node);
             return makeNodeFromSourceRange(context, 'String', start, end, {
               quasis,

src/util/makeString.ts

@@ -4,7 +4,7 @@ import { String } from '../nodes';
 import getTemplateLiteralComponents from './getTemplateLiteralComponents';
 import ParseContext from './ParseContext';
 
-export default function makeString(context: ParseContext, node: Base) {
+export default function makeString(context: ParseContext, node: Base): String {
   let { quasis, unmappedExpressions, start, end } = getTemplateLiteralComponents(context, node);
   let startLoc = context.linesAndColumns.locationForIndex(start);
   if (!startLoc) {