Add support for super keyword

Author: rhendric

src/Language/JavaScript/Parser/Grammar7.y

@@ -117,6 +117,7 @@ import qualified Language.JavaScript.Parser.AST as AST
      'return'     { ReturnToken {} }
      'set'        { SetToken {} }
      'static'     { StaticToken {} }
+     'super'      { SuperToken {} }
      'switch'     { SwitchToken {} }
      'this'       { ThisToken {} }
      'throw'      { ThrowToken {} }
@@ -357,6 +358,7 @@ IdentifierName : Identifier {$1}
              | 'of'         { AST.JSIdentifier (mkJSAnnot $1) "of" }
              | 'return'     { AST.JSIdentifier (mkJSAnnot $1) "return" }
              | 'static'     { AST.JSIdentifier (mkJSAnnot $1) "static" }
+             | 'super'      { AST.JSIdentifier (mkJSAnnot $1) "super" }
              | 'switch'     { AST.JSIdentifier (mkJSAnnot $1) "switch" }
              | 'this'       { AST.JSIdentifier (mkJSAnnot $1) "this" }
              | 'throw'      { AST.JSIdentifier (mkJSAnnot $1) "throw" }
@@ -450,6 +452,9 @@ Extends : 'extends' { mkJSAnnot $1 }
 Static :: { AST.JSAnnot }
 Static : 'static' { mkJSAnnot $1 }
 
+Super :: { AST.JSExpression }
+Super : 'super' { AST.JSLiteral (mkJSAnnot $1) "super" }
+
 
 Eof :: { AST.JSAnnot }
 Eof : 'tail' { mkJSAnnot $1 {- 'Eof' -} }
@@ -641,6 +646,8 @@ MemberExpression : PrimaryExpression   { $1 {- 'MemberExpression1' -} }
                  | MemberExpression LSquare Expression RSquare { AST.JSMemberSquare $1 $2 $3 $4 {- 'MemberExpression3' -} }
                  | MemberExpression Dot IdentifierName         { AST.JSMemberDot $1 $2 $3       {- 'MemberExpression4' -} }
                  | MemberExpression TemplateLiteral            { mkJSTemplateLiteral (Just $1) $2 }
+                 | Super LSquare Expression RSquare            { AST.JSMemberSquare $1 $2 $3 $4 }
+                 | Super Dot IdentifierName                    { AST.JSMemberDot $1 $2 $3 }
                  | New MemberExpression Arguments              { mkJSMemberNew $1 $2 $3         {- 'MemberExpression5' -} }
 
 -- NewExpression :                                              See 11.2
@@ -658,6 +665,8 @@ NewExpression : MemberExpression    { $1                        {- 'NewExpressio
 CallExpression :: { AST.JSExpression }
 CallExpression : MemberExpression Arguments
                     { mkJSMemberExpression $1 $2 {- 'CallExpression1' -} }
+               | Super Arguments
+                    { mkJSCallExpression $1 $2 }
                | CallExpression Arguments
                     { mkJSCallExpression $1 $2 {- 'CallExpression2' -} }
                | CallExpression LSquare Expression RSquare

src/Language/JavaScript/Parser/Lexer.x

@@ -565,6 +565,7 @@ keywordNames =
     , ( "of", OfToken )
     , ( "return", ReturnToken )
     , ( "static", StaticToken )
+    , ( "super", SuperToken )
     , ( "switch", SwitchToken )
     , ( "this", ThisToken )
     , ( "throw", ThrowToken )
@@ -599,7 +600,7 @@ keywordNames =
     -- ( "const",   FutureToken ) **** an actual token, used in productions
     -- enum                    **** an actual token, used in productions
     -- ( "extends",  FutureToken ) **** an actual token, used in productions
-    , ( "super",    FutureToken )
+    -- ( "super",    FutureToken ) **** an actual token, used in productions
 
 
     -- Strict mode FutureReservedWords

src/Language/JavaScript/Parser/Token.hs

@@ -83,6 +83,7 @@ data Token
     | OfToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
     | ReturnToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
     | StaticToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
+    | SuperToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
     | SwitchToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
     | ThisToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }
     | ThrowToken { tokenSpan :: !TokenPosn, tokenLiteral :: !String, tokenComment :: ![CommentAnnotation]  }

test/Test/Language/Javascript/ExpressionParser.hs

@@ -193,6 +193,7 @@ testExpressionParser = describe "Parse expressions:" $ do
     it "class expression" $ do
         testExpr "class Foo extends Bar { a(x,y) {} *b() {} }" `shouldBe` "Right (JSAstExpression (JSClassExpression 'Foo' (JSIdentifier 'Bar') [JSMethodDefinition (JSIdentifier 'a') (JSIdentifier 'x',JSIdentifier 'y') (JSBlock []),JSGeneratorMethodDefinition (JSIdentifier 'b') () (JSBlock [])]))"
         testExpr "class { static get [a]() {}; }" `shouldBe` "Right (JSAstExpression (JSClassExpression '' () [JSClassStaticMethod (JSPropertyAccessor JSAccessorGet (JSPropertyComputed (JSIdentifier 'a')) () (JSBlock [])),JSClassSemi]))"
+        testExpr "class Foo extends Bar { a(x,y) { super(x); } }" `shouldBe` "Right (JSAstExpression (JSClassExpression 'Foo' (JSIdentifier 'Bar') [JSMethodDefinition (JSIdentifier 'a') (JSIdentifier 'x',JSIdentifier 'y') (JSBlock [JSCallExpression (JSLiteral 'super',JSArguments (JSIdentifier 'x')),JSSemicolon])]))"
 
 
 testExpr :: String -> String

test/Test/Language/Javascript/StatementParser.hs

@@ -128,6 +128,7 @@ testStatementParser = describe "Parse statements:" $ do
     it "class" $ do
         testStmt "class Foo extends Bar { a(x,y) {} *b() {} }" `shouldBe` "Right (JSAstStatement (JSClass 'Foo' (JSIdentifier 'Bar') [JSMethodDefinition (JSIdentifier 'a') (JSIdentifier 'x',JSIdentifier 'y') (JSBlock []),JSGeneratorMethodDefinition (JSIdentifier 'b') () (JSBlock [])]))"
         testStmt "class Foo { static get [a]() {}; }" `shouldBe` "Right (JSAstStatement (JSClass 'Foo' () [JSClassStaticMethod (JSPropertyAccessor JSAccessorGet (JSPropertyComputed (JSIdentifier 'a')) () (JSBlock [])),JSClassSemi]))"
+        testStmt "class Foo extends Bar { a(x,y) { super[x](y); } }" `shouldBe` "Right (JSAstStatement (JSClass 'Foo' (JSIdentifier 'Bar') [JSMethodDefinition (JSIdentifier 'a') (JSIdentifier 'x',JSIdentifier 'y') (JSBlock [JSMethodCall (JSMemberSquare (JSLiteral 'super',JSIdentifier 'x'),JSArguments (JSIdentifier 'y')),JSSemicolon])]))"
 
 
 testStmt :: String -> String