extract expression types into separate files

langserver/java/body-parser3.js

@@ -14,8 +14,19 @@ const { resolveTypeOrPackage, resolveNextTypeOrPackage } = require('./type-resol
 const { genericTypeArgs, typeIdent, typeIdentList } = require('./typeident');
 const { TokenList } = require("./TokenList");
 const { AnyMethod, AnyType, AnyValue, ArrayLiteral, Label, LiteralNumber, LiteralValue, Local,
-    MethodDeclarations, ResolvedIdent, Value, ValueBase } = require("./body-types");
+    MethodDeclarations, ResolvedIdent, Value, } = require("./body-types");
 const { resolveImports, resolveSingleImport } = require('../java/import-resolver');
+const { ArrayIndexExpression } = require("./expressiontypes/ArrayIndexExpression");
+const { BinaryOpExpression } = require("./expressiontypes/BinaryOpExpression");
+const { BracketedExpression } = require("./expressiontypes/BracketedExpression");
+const { CastExpression } = require("./expressiontypes/CastExpression");
+const { ClassMemberExpression } = require("./expressiontypes/ClassMemberExpression");
+const { IncDecExpression } = require("./expressiontypes/IncDecExpression");
+const { LambdaExpression } = require("./expressiontypes/LambdaExpression");
+const { MemberExpression } = require("./expressiontypes/MemberExpression");
+const { MethodCallExpression } = require("./expressiontypes/MethodCallExpression");
+const { TernaryOpExpression } = require("./expressiontypes/TernaryOpExpression");
+const { ThisMemberExpression } = require("./expressiontypes/ThisMemberExpression");
 
 /**
  * @typedef {SourceMethod|SourceConstructor|SourceInitialiser} SourceMC
@@ -480,140 +491,6 @@ class AssertStatement extends Statement {
     message = null;
 }
 
-class Expression extends ValueBase {}
-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;
-    }
-}
-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;
-    }
-}
-class CastExpression extends Expression {
-    /**
-     * @param {ResolvedIdent} castType 
-     * @param {ResolvedIdent} expression 
-     */
-    constructor(castType, expression) {
-        super();
-        this.castType = castType;
-        this.expression = expression;
-    }
-}
-class BracketedExpression extends Expression {
-    /**
-     * @param {ResolvedIdent} expression 
-     */
-    constructor(expression) {
-        super();
-        this.expression = expression;
-    }
-}
-class LambdaExpression extends Expression {
-    /**
-     * 
-     * @param {*[]} params 
-     * @param {Expression|Block} body 
-     */
-    constructor(params, body) {
-        super();
-        this.params = params;
-        this.body = body;
-    }
-}
-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;
-    }
-}
-class MethodCallExpression extends Expression {
-    /**
-     * @param {ResolvedIdent} instance 
-     * @param {ResolvedIdent[]} args 
-     */
-    constructor(instance, args) {
-        super();
-        this.instance = instance;
-        this.args = args;
-    }
-
-}
-
-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;
-    }
-}
-
-class ThisMemberExpression extends Expression {
-    /**
-     * @param {ResolvedIdent} instance 
-     * @param {Token} this_token 
-     */
-    constructor(instance, this_token) {
-        super();
-        this.instance = instance;
-        this.thisToken = this_token;
-    }
-}
-
-class ClassMemberExpression extends Expression {
-    /**
-     * @param {ResolvedIdent} instance 
-     * @param {Token} class_token 
-     */
-    constructor(instance, class_token) {
-        super();
-        this.instance = instance;
-        this.classToken = class_token;
-    }
-}
-
-class ArrayIndexExpression extends Expression {
-    /**
-     * @param {ResolvedIdent} instance 
-     * @param {ResolvedIdent} index 
-     */
-    constructor(instance, index) {
-        super();
-        this.instance = instance;
-        this.index = index;
-    }
-}
-
 /**
 * @param {Token[]} modifiers
 * @param {TokenList} tokens 

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;