Parsing of simple method invocation with arguments

nurkiewicz · Oct 6, 2017 · 87947b3 · 87947b3
1 parent de7dda9
commit 87947b3
Show file tree

Hide file tree

Showing 6 changed files with 79 additions and 4 deletions.
diff --git a/src/main/kotlin/com/nurkiewicz/tsclass/parser/ast/expr/MethodCall.kt b/src/main/kotlin/com/nurkiewicz/tsclass/parser/ast/expr/MethodCall.kt
@@ -0,0 +1,12 @@
+package com.nurkiewicz.tsclass.parser.ast.expr
+
+data class MethodCall(val name: String, val parameters: List<Expression>): Expression {
+    companion object {
+
+        @JvmStatic
+        fun call(name: String, vararg parameters: Expression): MethodCall {
+            return MethodCall(name, parameters.toList())
+        }
+    }
+
+}
diff --git a/src/main/kotlin/com/nurkiewicz/tsclass/parser/visitors/ArgumentListVisitor.kt b/src/main/kotlin/com/nurkiewicz/tsclass/parser/visitors/ArgumentListVisitor.kt
@@ -0,0 +1,26 @@
+package com.nurkiewicz.tsclass.parser.visitors
+
+import com.nurkiewicz.tsclass.antlr.parser.TypeScriptBaseVisitor
+import com.nurkiewicz.tsclass.antlr.parser.TypeScriptParser
+import com.nurkiewicz.tsclass.parser.ast.expr.Expression
+
+class ArgumentListVisitor: TypeScriptBaseVisitor<List<Expression>>() {
+
+//    override fun visitArgumentList(ctx: TypeScriptParser.ArgumentListContext): List<Expression> {
+//        println(ctx.text)
+//        return super.visitArgumentList(ctx)
+//    }
+
+    override fun defaultResult(): List<Expression> {
+        return emptyList()
+    }
+
+    override fun visitAssignmentExpression(ctx: TypeScriptParser.AssignmentExpressionContext): List<Expression> {
+        println(ctx.text)
+        return listOf(ctx.accept(ExpressionVisitor()))
+    }
+
+    override fun aggregateResult(aggregate: List<Expression>, nextResult: List<Expression>): List<Expression> {
+        return aggregate + nextResult
+    }
+}
diff --git a/src/main/kotlin/com/nurkiewicz/tsclass/parser/visitors/LeftHandSideExpressionVisitor.kt b/src/main/kotlin/com/nurkiewicz/tsclass/parser/visitors/LeftHandSideExpressionVisitor.kt
@@ -0,0 +1,24 @@
+package com.nurkiewicz.tsclass.parser.visitors
+
+import com.nurkiewicz.tsclass.antlr.parser.TypeScriptBaseVisitor
+import com.nurkiewicz.tsclass.antlr.parser.TypeScriptParser
+import com.nurkiewicz.tsclass.parser.ast.expr.Expression
+import com.nurkiewicz.tsclass.parser.ast.expr.Identifier
+import com.nurkiewicz.tsclass.parser.ast.expr.MethodCall
+
+internal class LeftHandSideExpressionVisitor: TypeScriptBaseVisitor<Expression>() {
+
+    override fun visitLeftHandSideExpression(ctx: TypeScriptParser.LeftHandSideExpressionContext): Expression {
+        val call = ctx.callExpression()
+        if (call != null) {
+            val identifier = call.memberExpression().accept(MemberExpressionVisitor()) as Identifier
+            val arguments = if (call.arguments() != null)
+                call.arguments().accept(ArgumentListVisitor())
+            else
+                emptyList()
+            return MethodCall(identifier.name, arguments)
+        } else {
+            return ctx.accept(MemberExpressionVisitor())
+        }
+    }
+}
diff --git a/src/main/kotlin/com/nurkiewicz/tsclass/parser/visitors/MemberExpressionVisitor.kt b/src/main/kotlin/com/nurkiewicz/tsclass/parser/visitors/MemberExpressionVisitor.kt
@@ -12,10 +12,10 @@ internal class MemberExpressionVisitor : TypeScriptBaseVisitor<Expression>() {
             return ctx.expression().accept(ExpressionVisitor())
         }
         return if (ctx.IDENT() != null) {
-            Identifier(ctx.IDENT().getText())
+            Identifier(ctx.IDENT().text)
         } else ctx.accept(object : TypeScriptBaseVisitor<Expression>() {
             override fun visitLiteral(ctx: TypeScriptParser.LiteralContext): Expression {
-                return NumberLiteral(java.lang.Double.valueOf(ctx.NUMERIC_LITERAL().getText()))
+                return NumberLiteral(java.lang.Double.valueOf(ctx.NUMERIC_LITERAL().text))
             }
         })
     }

diff --git a/src/main/kotlin/com/nurkiewicz/tsclass/parser/visitors/MultiplicativeExpressionVisitor.kt b/src/main/kotlin/com/nurkiewicz/tsclass/parser/visitors/MultiplicativeExpressionVisitor.kt
@@ -8,7 +8,7 @@ import com.nurkiewicz.tsclass.parser.ast.expr.MultiplicativeExpression
 internal class MultiplicativeExpressionVisitor : TypeScriptBaseVisitor<Expression>() {
 
     override fun visitMultiplicativeExpression(ctx: TypeScriptParser.MultiplicativeExpressionContext): Expression {
-        val right = ctx.accept(MemberExpressionVisitor())
+        val right = ctx.accept(LeftHandSideExpressionVisitor())
         if (ctx.multiplicativeExpression() != null) {
             val left = ctx.multiplicativeExpression().accept(this)
             val op = MultiplicativeExpression.Operator.of(ctx.op.getText())

diff --git a/src/test/groovy/com/nurkiewicz/tsclass/parser/visitors/ExpressionVisitorTest.groovy b/src/test/groovy/com/nurkiewicz/tsclass/parser/visitors/ExpressionVisitorTest.groovy
@@ -17,6 +17,7 @@ import static com.nurkiewicz.tsclass.parser.ast.expr.AdditiveExpression.Operator
 import static com.nurkiewicz.tsclass.parser.ast.expr.AdditiveExpression.add
 import static com.nurkiewicz.tsclass.parser.ast.expr.AdditiveExpression.sub
 import static com.nurkiewicz.tsclass.parser.ast.expr.Identifier.ident
+import static com.nurkiewicz.tsclass.parser.ast.expr.MethodCall.call
 import static com.nurkiewicz.tsclass.parser.ast.expr.MultiplicativeExpression.Operator.DIV
 import static com.nurkiewicz.tsclass.parser.ast.expr.MultiplicativeExpression.Operator.MOD
 import static com.nurkiewicz.tsclass.parser.ast.expr.MultiplicativeExpression.Operator.MUL
@@ -74,7 +75,20 @@ class ExpressionVisitorTest extends Specification {
             '1 + 2 - 3 + 4 + 5' || add(add(sub(add(num(1), num(2)), num(3)), num(4)), num(5))
             '1 * 2 / 3 * 4 % 5' || mod(mul(div(mul(num(1), num(2)), num(3)), num(4)), num(5))
             '(x * y) + (a / b)' || add(mul(ident("x"), ident("y")), div(ident("a"), ident("b")))
+    }
 
+    def 'should parse method invocation #expr to #obj'() {
+        expect:
+            parse(expr) == obj
+        where:
+            expr  || obj
+            'f()' || call("f")
+            'g(1)'        || call("g", num(1))
+            'hi(x)'       || call("hi", ident("x"))
+            'jkl(1, 2)'   || call("jkl", num(1), num(2))
+            'm(x, y + 3)' || call("m", ident("x"), add(ident("y"), num(3)))
+            '1 + f()'     || add(num(1), call("f"))
+            'g(4) * f()'  || mul(call("g", num(4)), call("f"))
     }
 
     private static Expression parse(String value) {
@@ -85,7 +99,6 @@ class ExpressionVisitorTest extends Specification {
                     }
                 }
             """
-//        AstWindow.open(code)
         ClassDescriptor cls = new Parser().parse(code)
         Method method = cls.methods[0]
         ReturnStatement statement = method.statements[0] as ReturnStatement