parse arrow functions.

Author: diasbruno

src/Language/JavaScript/Parser/AST.hs

@@ -99,6 +99,7 @@ data JSExpression
     | JSExpressionParen !JSAnnot !JSExpression !JSAnnot -- ^lb,expression,rb
     | JSExpressionPostfix !JSExpression !JSUnaryOp -- ^expression, operator
     | JSExpressionTernary !JSExpression !JSAnnot !JSExpression !JSAnnot !JSExpression -- ^cond, ?, trueval, :, falseval
+    | JSArrowExpression !JSAnnot !(JSCommaList JSIdent) !JSAnnot !JSAnnot !(Either JSExpression JSBlock) -- ^parameter list,arrow,block`
     | JSFunctionExpression !JSAnnot !JSIdent !JSAnnot !(JSCommaList JSIdent) !JSAnnot !JSBlock -- ^fn,name,lb, parameter list,rb,block`
     | JSMemberDot !JSExpression !JSAnnot !JSExpression -- ^firstpart, dot, name
     | JSMemberExpression !JSExpression !JSAnnot !(JSCommaList JSExpression) !JSAnnot -- expr, lb, args, rb
@@ -296,6 +297,8 @@ instance ShowStripped JSExpression where
     ss (JSExpressionParen _lp x _rp) = "JSExpressionParen (" ++ ss x ++ ")"
     ss (JSExpressionPostfix xs op) = "JSExpressionPostfix (" ++ ss op ++ "," ++ ss xs ++ ")"
     ss (JSExpressionTernary x1 _q x2 _c x3) = "JSExpressionTernary (" ++ ss x1 ++ "," ++ ss x2 ++ "," ++ ss x3 ++ ")"
+    ss (JSArrowExpression _ n _ _ (Right bd)) = "JSArrowExpression (" ++ ss n ++ ") => " ++ ss bd
+    ss (JSArrowExpression _ n _ _ (Left bd)) = "JSArrowExpression (" ++ ss n ++ ") => " ++ ss bd
     ss (JSFunctionExpression _ n _lb pl _rb x3) = "JSFunctionExpression " ++ ssid n ++ " " ++ ss pl ++ " (" ++ ss x3 ++ "))"
     ss (JSHexInteger _ s) = "JSHexInteger " ++ singleQuote s
     ss (JSOctal _ s) = "JSOctal " ++ singleQuote s

src/Language/JavaScript/Parser/Grammar7.y

@@ -39,6 +39,7 @@ import qualified Language.JavaScript.Parser.AST as AST
      '|'    { BitwiseOrToken {} }
      '^'    { BitwiseXorToken {} }
      '&'    { BitwiseAndToken {} }
+     '=>'   { ArrowToken {} }
      '==='  { StrictEqToken {} }
      '=='   { EqToken {} }
      '*='   { TimesAssignToken {} }
@@ -182,6 +183,9 @@ Colon : ':' { mkJSAnnot $1 }
 Semi :: { AST.JSAnnot }
 Semi : ';' { mkJSAnnot $1 }
 
+Arrow :: { AST.JSAnnot }
+Arrow : '=>' { mkJSAnnot $1 }
+
 Spread :: { AST.JSAnnot }
 Spread : '...' { mkJSAnnot $1 }
 
@@ -1106,8 +1110,15 @@ FunctionDeclaration : NamedFunctionExpression MaybeSemi  {  expressionToStatemen
 -- FunctionExpression :                                                       See clause 13
 --        function Identifieropt ( FormalParameterListopt ) { FunctionBody }
 FunctionExpression :: { AST.JSExpression }
-FunctionExpression : LambdaExpression           { $1     {- 'FunctionExpression1' -} }
-                   | NamedFunctionExpression     { $1     {- 'FunctionExpression2' -} }
+FunctionExpression : ArrowFunctionExpression     { $1 {- 'ArrowFunctionExpression' -} }
+                   | LambdaExpression            { $1 {- 'FunctionExpression1' -} }
+                   | NamedFunctionExpression     { $1 {- 'FunctionExpression2' -} }
+
+ArrowFunctionExpression :: { AST.JSExpression }
+ArrowFunctionExpression : LParen FormalParameterList RParen Arrow Expression
+                           { AST.JSArrowExpression $1 $2 $3 $4 (Left $5) }
+                        | LParen FormalParameterList RParen Arrow FunctionBody
+                           { AST.JSArrowExpression $1 $2 $3 $4 (Right $5) }
 
 NamedFunctionExpression :: { AST.JSExpression }
 NamedFunctionExpression : Function Identifier LParen RParen FunctionBody

src/Language/JavaScript/Parser/Lexer.x

@@ -290,6 +290,7 @@ tokens :-
     "|"     { adapt (symbolToken  BitwiseOrToken) }
     "^"     { adapt (symbolToken  BitwiseXorToken) }
     "&"     { adapt (symbolToken  BitwiseAndToken) }
+    "=>"    { adapt (symbolToken  ArrowToken) }
     "==="   { adapt (symbolToken  StrictEqToken) }
     "=="    { adapt (symbolToken  EqToken) }
     "*="    { adapt (symbolToken  TimesAssignToken) }

src/Language/JavaScript/Parser/Token.hs

@@ -141,6 +141,7 @@ data Token
     | ModToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
     | NotToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
     | BitwiseNotToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
+    | ArrowToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
     | SpreadToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
     | DotToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }
     | LeftBracketToken { tokenSpan :: !TokenPosn, tokenComment :: ![CommentAnnotation]  }

test/Test/Language/Javascript/ExpressionParser.hs

@@ -123,6 +123,8 @@ testExpressionParser = describe "Parse expressions:" $ do
         testExpr "function(){}"     `shouldBe` "Right (JSAstExpression (JSFunctionExpression '' () (JSBlock []))))"
         testExpr "function(a){}"    `shouldBe` "Right (JSAstExpression (JSFunctionExpression '' (JSIdentifier 'a') (JSBlock []))))"
         testExpr "function(a,b){}"  `shouldBe` "Right (JSAstExpression (JSFunctionExpression '' (JSIdentifier 'a',JSIdentifier 'b') (JSBlock []))))"
+        testExpr "(a,b) => {}"  `shouldBe` "Right (JSAstExpression (JSArrowExpression ((JSIdentifier 'a',JSIdentifier 'b')) => JSBlock []))"
+        testExpr "(a,b) => a + b"  `shouldBe` "Right (JSAstExpression (JSArrowExpression ((JSIdentifier 'a',JSIdentifier 'b')) => JSExpressionBinary ('+',JSIdentifier 'a',JSIdentifier 'b')))"
 
     it "member expression" $ do
         testExpr "x[y]"         `shouldBe` "Right (JSAstExpression (JSMemberSquare (JSIdentifier 'x',JSIdentifier 'y')))"