support token extraction in expressions

langserver/java/expressiontypes/ArrayIndexExpression.js

@@ -13,6 +13,10 @@ class ArrayIndexExpression extends Expression {
         this.instance = instance;
         this.index = index;
     }
+
+    tokens() {
+        return [...this.instance.tokens, ...this.index.tokens];
+    }
 }
 
 exports.ArrayIndexExpression = ArrayIndexExpression;

langserver/java/expressiontypes/ArrayValueExpression.js

@@ -1,15 +1,22 @@
 /**
  * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../tokenizer').Token} Token
  */
 const { Expression } = require("./Expression");
 
 class ArrayValueExpression extends Expression {
     /**
      * @param {ResolvedIdent[]} elements 
+     * @param {Token} open 
      */
-    constructor(elements) {
+    constructor(elements, open) {
         super();
         this.elements = elements;
+        this.open = open;
+    }
+
+    tokens() {
+        return this.open;
     }
 }
 

langserver/java/expressiontypes/BinaryOpExpression.js

@@ -16,6 +16,10 @@ class BinaryOpExpression extends Expression {
         this.op = op;
         this.rhs = rhs;
     }
+
+    tokens() {
+        return [...this.lhs.tokens, this.op, ...this.rhs.tokens];
+    }
 }
 
 exports.BinaryOpExpression = BinaryOpExpression;

langserver/java/expressiontypes/BracketedExpression.js

@@ -11,6 +11,10 @@ class BracketedExpression extends Expression {
         super();
         this.expression = expression;
     }
+
+    tokens() {
+        return this.expression.tokens;
+    }
 }
 
 exports.BracketedExpression = BracketedExpression;

langserver/java/expressiontypes/CastExpression.js

@@ -13,6 +13,10 @@ class CastExpression extends Expression {
         this.castType = castType;
         this.expression = expression;
     }
+
+    tokens() {
+        return [...this.castType.tokens, ...this.expression.tokens];
+    }
 }
 
 exports.CastExpression = CastExpression;

langserver/java/expressiontypes/ClassMemberExpression.js

@@ -14,5 +14,9 @@ class ClassMemberExpression extends Expression {
         this.instance = instance;
         this.classToken = class_token;
     }
+
+    tokens() {
+        return this.classToken;
+    }
 }
 exports.ClassMemberExpression = ClassMemberExpression;

langserver/java/expressiontypes/Expression.js

@@ -1,5 +1,12 @@
+/**
+ * @typedef {import('../tokenizer').Token} Token
+ */
 
 class Expression {
+    /** @returns {Token|Token[]} */
+    tokens() {
+        throw new Error('Expression.tokens');
+    }
 }
 
 exports.Expression = Expression;

langserver/java/expressiontypes/IncDecExpression.js

@@ -16,6 +16,10 @@ class IncDecExpression extends Expression {
         this.operator = operator;
         this.which = which;
     }
+
+    tokens() {
+        return this.operator;
+    }
 }
 
 exports.IncDecExpression = IncDecExpression;

langserver/java/expressiontypes/LambdaExpression.js

@@ -1,19 +1,26 @@
 /**
  * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
- * @typedef {import('../statementtypes/Block').Block} Block
  */
 const { Expression } = require("./Expression");
+const { Block } = require('../statementtypes/Block');
 
 class LambdaExpression extends Expression {
     /**
      *
      * @param {*[]} params
-     * @param {Expression|Block} body
+     * @param {ResolvedIdent|Block} body
      */
     constructor(params, body) {
         super();
         this.params = params;
         this.body = body;
     }
+
+    tokens() {
+        if (this.body instanceof Block) {
+            return this.body.open; 
+        }
+        return this.body.tokens;
+    }
 }
 exports.LambdaExpression = LambdaExpression;

langserver/java/expressiontypes/MemberExpression.js

@@ -15,6 +15,10 @@ class MemberExpression extends Expression {
         // member will be null for incomplete expressions
         this.member = member;
     }
+
+    tokens() {
+        return this.member;
+    }
 }
 
 exports.MemberExpression = MemberExpression;

langserver/java/expressiontypes/MethodCallExpression.js

@@ -13,6 +13,10 @@ class MethodCallExpression extends Expression {
         this.instance = instance;
         this.args = args;
     }
+
+    tokens() {
+        return this.instance.tokens;
+    }
 }
 
 exports.MethodCallExpression = MethodCallExpression;

langserver/java/expressiontypes/NewExpression.js

@@ -1,34 +1,47 @@
 /**
  * @typedef {import('../tokenizer').Token} Token
  * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../source-types').SourceTypeIdent} SourceTypeIdent
  * @typedef {import('java-mti').JavaType} JavaType
  */
 const { Expression } = require("./Expression");
 
 class NewArray extends Expression {
     /**
-     * @param {JavaType} element_type
+     * @param {Token} new_token
+     * @param {SourceTypeIdent} element_type
      * @param {ResolvedIdent} dimensions
      */
-    constructor(element_type, dimensions) {
+    constructor(new_token, element_type, dimensions) {
         super();
+        this.new_token = new_token;
         this.element_type = element_type;
         this.dimensions = dimensions;
     }
+
+    tokens() {
+        return [this.new_token, ...this.element_type.tokens, ...this.dimensions.tokens];
+    }
 }
 
 class NewObject extends Expression {
     /**
-     * @param {JavaType} object_type
+     * @param {Token} new_token
+     * @param {SourceTypeIdent} object_type
      * @param {ResolvedIdent[]} ctr_args
      * @param {Token[]} type_body
      */
-    constructor(object_type, ctr_args, type_body) {
+    constructor(new_token, object_type, ctr_args, type_body) {
         super();
-        this.element_type = object_type;
+        this.new_token = new_token;
+        this.object_type = object_type;
         this.ctr_args = ctr_args;
         this.type_body = type_body;
     }
+
+    tokens() {
+        return [this.new_token, ...this.object_type.tokens];
+    }
 }
 
 exports.NewArray = NewArray;

langserver/java/expressiontypes/TernaryOpExpression.js

@@ -15,6 +15,10 @@ class TernaryOpExpression extends Expression {
         this.truthExpression = truthExpression;
         this.falseExpression = falseExpression;
     }
+
+    tokens() {
+        return [...this.test.tokens, ...this.truthExpression.tokens, ...this.falseExpression.tokens];
+    }
 }
 
 exports.TernaryOpExpression = TernaryOpExpression;

langserver/java/expressiontypes/ThisMemberExpression.js

@@ -14,6 +14,10 @@ class ThisMemberExpression extends Expression {
         this.instance = instance;
         this.thisToken = this_token;
     }
+
+    tokens() {
+        return this.thisToken;
+    }
 }
 
 exports.ThisMemberExpression = ThisMemberExpression;

langserver/java/expressiontypes/Variable.js

@@ -0,0 +1,28 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../body-types').Local} Local
+ * @typedef {import('../tokenizer').Token} Token
+ * @typedef {import('java-mti').Field} Field
+ * @typedef {import('java-mti').Parameter} Parameter
+ * @typedef {import('../source-types').SourceEnumValue} SourceEnumValue
+ */
+const { Expression } = require("./Expression");
+
+class Variable extends Expression {
+    /**
+     * @param {Token} name_token
+     * @param {Local|Parameter|Field|SourceEnumValue} variable
+     */
+    constructor(name_token, variable) {
+        super();
+        this.name_token = name_token;
+        this.variable = variable;
+        this.type = this.variable.type;
+    }
+
+    tokens() {
+        return this.name_token;
+    }
+}
+
+exports.Variable = Variable;

langserver/java/expressiontypes/literals/LiteralValue.js

@@ -11,6 +11,10 @@ class LiteralValue extends Expression {
         super();
         this.token = token;
     }
+
+    tokens() {
+        return this.token;
+    }
 }
 
 exports.LiteralValue = LiteralValue;