extract expression types into separate files

langserver/java/expressiontypes/ArrayIndexExpression.js

@@ -0,0 +1,18 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ */
+const { Expression } = require("./Expression");
+
+class ArrayIndexExpression extends Expression {
+    /**
+     * @param {ResolvedIdent} instance
+     * @param {ResolvedIdent} index
+     */
+    constructor(instance, index) {
+        super();
+        this.instance = instance;
+        this.index = index;
+    }
+}
+
+exports.ArrayIndexExpression = ArrayIndexExpression;

langserver/java/expressiontypes/BinaryOpExpression.js

@@ -0,0 +1,21 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../tokenizer').Token} Token
+ */
+const { Expression } = require("./Expression");
+
+class BinaryOpExpression extends Expression {
+    /**
+     * @param {ResolvedIdent} lhs
+     * @param {Token} op
+     * @param {ResolvedIdent} rhs
+     */
+    constructor(lhs, op, rhs) {
+        super();
+        this.lhs = lhs;
+        this.op = op;
+        this.rhs = rhs;
+    }
+}
+
+exports.BinaryOpExpression = BinaryOpExpression;

langserver/java/expressiontypes/BracketedExpression.js

@@ -0,0 +1,16 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ */
+const { Expression } = require("./Expression");
+
+class BracketedExpression extends Expression {
+    /**
+     * @param {ResolvedIdent} expression
+     */
+    constructor(expression) {
+        super();
+        this.expression = expression;
+    }
+}
+
+exports.BracketedExpression = BracketedExpression;

langserver/java/expressiontypes/CastExpression.js

@@ -0,0 +1,18 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ */
+const { Expression } = require("./Expression");
+
+class CastExpression extends Expression {
+    /**
+     * @param {ResolvedIdent} castType
+     * @param {ResolvedIdent} expression
+     */
+    constructor(castType, expression) {
+        super();
+        this.castType = castType;
+        this.expression = expression;
+    }
+}
+
+exports.CastExpression = CastExpression;

langserver/java/expressiontypes/ClassMemberExpression.js

@@ -0,0 +1,18 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../tokenizer').Token} Token
+ */
+const { Expression } = require("./Expression");
+
+class ClassMemberExpression extends Expression {
+    /**
+     * @param {ResolvedIdent} instance
+     * @param {Token} class_token
+     */
+    constructor(instance, class_token) {
+        super();
+        this.instance = instance;
+        this.classToken = class_token;
+    }
+}
+exports.ClassMemberExpression = ClassMemberExpression;

langserver/java/expressiontypes/Expression.js

@@ -0,0 +1,6 @@
+const { ValueBase } = require("../body-types");
+
+class Expression extends ValueBase {
+}
+
+exports.Expression = Expression;

langserver/java/expressiontypes/IncDecExpression.js

@@ -0,0 +1,21 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../tokenizer').Token} Token
+ */
+const { Expression } = require("./Expression");
+
+class IncDecExpression extends Expression {
+    /**
+     * @param {ResolvedIdent} expr
+     * @param {Token} operator
+     * @param {'prefix'|'postfix'} which
+     */
+    constructor(expr, operator, which) {
+        super();
+        this.expr = expr;
+        this.operator = operator;
+        this.which = which;
+    }
+}
+
+exports.IncDecExpression = IncDecExpression;

langserver/java/expressiontypes/LambdaExpression.js

@@ -0,0 +1,19 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../tokenizer').Token} Token
+ */
+const { Expression } = require("./Expression");
+
+class LambdaExpression extends Expression {
+    /**
+     *
+     * @param {*[]} params
+     * @param {Expression|Block} body
+     */
+    constructor(params, body) {
+        super();
+        this.params = params;
+        this.body = body;
+    }
+}
+exports.LambdaExpression = LambdaExpression;

langserver/java/expressiontypes/MemberExpression.js

@@ -0,0 +1,20 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../tokenizer').Token} Token
+ */
+const { Expression } = require("./Expression");
+
+class MemberExpression extends Expression {
+    /**
+     * @param {ResolvedIdent} instance
+     * @param {Token|null} member
+     */
+    constructor(instance, member) {
+        super();
+        this.instance = instance;
+        // member will be null for incomplete expressions
+        this.member = member;
+    }
+}
+
+exports.MemberExpression = MemberExpression;

langserver/java/expressiontypes/MethodCallExpression.js

@@ -0,0 +1,18 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ */
+const { Expression } = require("./Expression");
+
+class MethodCallExpression extends Expression {
+    /**
+     * @param {ResolvedIdent} instance
+     * @param {ResolvedIdent[]} args
+     */
+    constructor(instance, args) {
+        super();
+        this.instance = instance;
+        this.args = args;
+    }
+}
+
+exports.MethodCallExpression = MethodCallExpression;

langserver/java/expressiontypes/TernaryOpExpression.js

@@ -0,0 +1,20 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ */
+const { Expression } = require("./Expression");
+
+class TernaryOpExpression extends Expression {
+    /**
+     * @param {ResolvedIdent} test
+     * @param {ResolvedIdent} truthExpression
+     * @param {ResolvedIdent} falseExpression
+     */
+    constructor(test, truthExpression, falseExpression) {
+        super();
+        this.test = test;
+        this.truthExpression = truthExpression;
+        this.falseExpression = falseExpression;
+    }
+}
+
+exports.TernaryOpExpression = TernaryOpExpression;

langserver/java/expressiontypes/ThisMemberExpression.js

@@ -0,0 +1,19 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../tokenizer').Token} Token
+ */
+const { Expression } = require("./Expression");
+
+class ThisMemberExpression extends Expression {
+    /**
+     * @param {ResolvedIdent} instance
+     * @param {Token} this_token
+     */
+    constructor(instance, this_token) {
+        super();
+        this.instance = instance;
+        this.thisToken = this_token;
+    }
+}
+
+exports.ThisMemberExpression = ThisMemberExpression;