version 1.2 (#93)

* initial working language server
* first hacky version of source parsing and type checking
* first iteration of method body parser
* add support for prefix/postfix inc expressions
* add basic support for parsing new expressions
* different attempt to parse using collapsable text ranges
* fix parsing of binary operstors following a bracket expression
* updated validation to use new JavaTypes module instead of MTIs
* add support for array-literal expressions
* fix || and && not being tokenized as operators allow float literals starting with dot
* add new method body parser to use direct linear parsing
* add super as an object literal
* fix interface constructors check constructor type modifiers
* fix assignment operator types
* Fix resolving of enclosed type identifiers
* add default constructor for class types with no explicit constructors
* add missing constructor validator
* add constructor parameters to list of resolvable types
* update SourceMethod to pass name in super constructor
* add Any* classes to reduce cascading errors
* update method call parameter checking use isTypeAssignable instead of getParameterCompatibleTypeSignatures
* tidy up isTypeAssignable allow class equivilents for primitives
* add more info when methods/ctrs cannot be matched
* allow interfaces to be cast to class instances
* use isTypeAssignable for checking branch test expressions
* allow AnyValue to be a constant value
* split shift operators from bitwise operators
* add support for literal numbers to be assignable to multiple primtive types
* clear diagnostics when document is closed
* update check for cast expression
* casting only applies to qualified term not a whole expression
* allow all primitive-number-type casts
* add support for synchronized statement
* update primitive type compatibility
* allow null to be cast to any non-primitve
* use better regex for string literals
* allow character literals to be assigned to number types
* add support for array qualifiers after a variable name
* make sure any long specifier is stripped from a bigint value
* improve invalid array expression message add AnyType array element to prevent cascading errors
* make default a modifer keyword for interface default method support
* initial support for wildcard type arguments
* fix parse issue with nested generic types
* allow generic types to be assigned to inherited types with compatible type arguments
* allow unicode characters, $ and _ in identifiers
* map primitive types to their boxed versions for class member
* support assert statement
* allow unicode char literals
* make type parser and body parser use same tokenizer
* reuse parsed tokens instead of tokenizing each method body
* re-add throws as a keyword
* treat default and synchronized as modifiers
* add SourceInitialiser support
* refactor to prepare for merging with type parsing
* add support for array qualifiers in type identifiers
* pass scoped type instead of method to typeIdent
* update ResolvableType to use same type resolving as method body parsing
* add support for post-name array qualifiers in fields and parameters
* post-name array qualifiers in method decls
* add type variables to SourceMethod
* initial attempt to support type variable arguments in methods
* specialise methods with type variables
* don't require default interface methods to be implemented
* make variable arity parameters an array type
* tidy array constructors and fix some warnings
* update isCallCompatible to handle variable arity calls
* improve assert statement support
* parse labels and break/continue targets
* refactor new term qualifiers
* add support for generic inferred-type arguments
* improve modifier checks for interface types
* improve reporting of unresolved type errors
* fix type checking of field and method declarations
* add missng strictfp modifier
* refactor in preparation for parsing local types
* replace Locals with scopeable MethodDeclarations to allow labels and types to be stored
* initial changes to support local type declarations
* update to use new set of SourceX classes
* refactor to allow expressions to have a type scope
* replace regex parsing with linear parsing
* generate source types before parsing
* fix support for resolving type variables in method declarations
* fix checking of array literal compatability
* report errors from unit parsing
* remove local modifier validation during parse add parameter modifier checking to validation
* allow trailing comma for array literals
* start separating validation from parsing
* add support for parsing enum values
* allow uppercase 0X in hex literals
* include enclosing types in identifier search
* add support for parsing parameterless lambdas
* ignore unresolved types in extends/implements
* implement specialisation of SourceType
* allow super as a member qualifier
* allow empty enums
* don't report missing constructors if superclass has none
* update typemap declarations to use CEIType instead of JavaType
* fix resolving of class type variables
* fix bad imports when resolving annotations
* allow null scope in findIdentifier
* add support for static member imports
* import types from same package
* remove this qualifier from isCastExpression
* add hex exponent support
* parse try-with-resources
* fix resolving imported enclosed types
* extract expression types into separate files
* extract statement types into separate files
* fix type warnings
* extract literals into separate files
* remove Value class, add NewExpression and separate out Any classes
* rename source types module
* remove some parse checks that should be in verify
* support token extraction in expressions
* implement resolveExpression
* add type cast checking
* check for valid type in class member expressions
* allow assigns for assignable type arguments
* improve reporting of unresolved identifiers
* add new array validation
* validate array literals
* validate array indexes
* improve validation of binary operators
* rename ResolvedType  to ResolvedValue
* improve checking of number literals
* support package name as a resolved value
* implement method body and ststement validation
* improve method call resolving
* add support for this() and super() constructor calls
* remove return type for source constructors
* add checks for unary operators
* ensure tokens are assigned for qualified expressions
* check castability using type assignments
* add implicit enum methods values() and valueOf()
* add basic type checking of lambda expressions
* fix return type check
* fix assert statement checks
* improve support for ternary operators in assignments and method invocations
* perform more detailed search of implemented methods
* initial test of context-dependant code completion
* support package, type and static field import completion
* support for member expressions
* use exact type signatures for locating types for completion items
* add support for field and method docs
* add support for docs in source types
* support member completion for array types improve comment formatting
* ensure Object is always last in the list of inherited types
* add owning method to statements create common keyword statement class
* improve code completion list add method parameters order list items by scope
* add source types to list hide this and super for non-methods
* fix bad member resolution at end of block fix missing method and type docs
* add support for editing multiple files
* allow multiple source files to be used in parsing
* load and parse files at startup
* add support for displaying method signatures
* add single trace function with timestamps
* implement shceduleReparse to reduce parsing load while typing
* remove parsed type list logging
* wait for reparsing before returning method signatures
* resolve new object contructors
* improve extraction of parameter docs
* update @types/vscode
* cache decoded android library in globalStoragePath
* load single android library cache from local folder
* android-29 library cache
* allow configurable app root setting
* set configurable trace logging and update section names
* description updates
* handle null token passed to ParseProblem
* refactoring
* Rename language client extension to Android
* ignore unnamed type declarations
* handle java file change notifications
* make sure we only try and parse java files
* add option to allow language server to be shutdown
* simplify handling of this and class member qualifiers
* relocate java-mti package into project
* get main node install to install langserver dependencies
* remove debugging pause
* rename body-parser3 to body-parser
* clean up import resolving code
* remove unused field from ResolvedImport
* remove validation modules that used old parser types
* remove old parser files
* remove redundant types and functions used by old parser
* move addproblem into TokenList
* remove unused ResolvedType class
* validate more statements
* add support for parsing and validating anonymous types
* hide some method modifiers which aren't useful to show
* code comments and minor improvements
* fix some type warnings
* improve support for completion of enum values
* add type name to parameter completion labels
* ignore synthetic members in completion list
* use a specialised map for handling case-insenstive file uris
* add basic build script
* reference java-mti package from GitHub
* revert @types/vscode
* update initial file loading to use URIs passed from the client changes to the appSourceRoot now require an extension restart
* add support for loading filtered androidx libraries for code completion
* update version of java-mti
* add mixpanel package
* add basic analytics
* fix dependency versions
* fix dependency versions
* set empty cache file markers
* add language server debug config
* add file to build script
* add unqualified type members when inside a method
* apply statics filter to enum values
* add basic debugger analytics
* include current time in startup event
* add terminate reason to debugger
* update changelog and readme

langserver/java/statementtypes/AssertStatement.js

@@ -0,0 +1,39 @@
+/**
+ * @typedef {import('../tokenizer').Token} Token
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ */
+const { KeywordStatement } = require("./KeywordStatement");
+const ParseProblem = require('../parsetypes/parse-problem');
+const { isTypeAssignable } = require('../expression-resolver');
+const { JavaType, PrimitiveType } = require('java-mti');
+
+class AssertStatement extends KeywordStatement {
+    /** @type {ResolvedIdent} */
+    expression = null;
+    /** @type {ResolvedIdent} */
+    message = null;
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        if (this.expression) {
+            const value = this.expression.resolveExpression(vi);
+            if (!(value instanceof JavaType) || !isTypeAssignable(PrimitiveType.map.Z, value)) {
+                vi.problems.push(ParseProblem.Error(this.expression.tokens, `Boolean expression expected`));
+            }
+        }
+
+        if (this.message) {
+            const msg_value = this.message.resolveExpression(vi);
+            if (!(msg_value instanceof JavaType)) {
+                vi.problems.push(ParseProblem.Error(this.message.tokens, `Expression expected`));
+            } else if (msg_value === PrimitiveType.map.V) {
+                vi.problems.push(ParseProblem.Error(this.message.tokens, `Expression type cannot be 'void'`));
+            }
+        }
+    }
+}
+
+exports.AssertStatement = AssertStatement;

langserver/java/statementtypes/Block.js

@@ -0,0 +1,46 @@
+/**
+ * @typedef {import('../tokenizer').Token} Token
+ * @typedef {import('../body-types').Local} Local
+ * @typedef {import('../body-types').Label} Label
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ * @typedef {import('../source-types').SourceType} SourceType
+ * @typedef {import('../source-types').SourceMethodLike} SourceMethodLike
+ */
+const { Statement } = require("./Statement");
+const ParseProblem = require('../parsetypes/parse-problem');
+
+class Block extends Statement {
+    /** @type {Statement[]} */
+    statements = [];
+
+    /** @type {{locals: Local[], labels: Label[], types: SourceType[]}} */
+    decls = null;
+
+    /**
+     * @param {SourceMethodLike} owner
+     * @param {Token} open 
+     */
+    constructor(owner, open) {
+        super(owner);
+        this.open = open;
+    }
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        if (this.decls) {
+            const locals = this.decls.locals.reverse();
+            locals.forEach(local => {
+                if (locals.find(l => l.name === local.name) !== local) {
+                    vi.problems.push(ParseProblem.Error(local.decltoken, `Variable redeclared: ${local.name}`))
+                }
+            });
+        }
+        for (let statement of this.statements) {
+            statement.validate(vi);
+        }
+    }
+}
+
+exports.Block = Block;

langserver/java/statementtypes/BreakStatement.js

@@ -0,0 +1,23 @@
+/**
+ * @typedef {import('../tokenizer').Token} Token
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ * @typedef {import('../source-types').SourceMethodLike} SourceMethodLike
+ */
+const { KeywordStatement } = require("./KeywordStatement");
+const ParseProblem = require('../parsetypes/parse-problem');
+
+class BreakStatement extends KeywordStatement {
+    /** @type {Token} */
+    target = null;
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        if (!vi.statementStack.find(s => /^(for|do|while|switch)$/.test(s))) {
+            vi.problems.push(ParseProblem.Error(this.keyword, `break can only be specified inside loop/switch statements`));
+        }
+    }
+}
+
+exports.BreakStatement = BreakStatement;

langserver/java/statementtypes/ContinueStatement.js

@@ -0,0 +1,23 @@
+/**
+ * @typedef {import('../tokenizer').Token} Token
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ * @typedef {import('../source-types').SourceMethodLike} SourceMethodLike
+ */
+const { KeywordStatement } = require("./KeywordStatement");
+const ParseProblem = require('../parsetypes/parse-problem');
+
+class ContinueStatement extends KeywordStatement {
+    /** @type {Token} */
+    target = null;
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        if (!vi.statementStack.find(s => /^(for|do|while)$/.test(s))) {
+            vi.problems.push(ParseProblem.Error(this.keyword, `continue can only be specified inside loop statements`));
+        }
+    }
+}
+
+exports.ContinueStatement = ContinueStatement;

langserver/java/statementtypes/DoStatement.js

@@ -0,0 +1,31 @@
+/**
+ * @typedef {import('../tokenizer').Token} Token
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ * @typedef {import('../expressiontypes/Expression').Expression} Expression
+ * @typedef {import('../statementtypes/Block').Block} Block
+ */
+const { KeywordStatement } = require("./KeywordStatement");
+const { checkBooleanBranchCondition } = require('../expression-resolver');
+
+class DoStatement extends KeywordStatement {
+    /** @type {ResolvedIdent} */
+    test = null;
+    /** @type {Block} */
+    block = null;
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        if (this.block) {
+            vi.statementStack.unshift('do');
+            this.block.validate(vi);
+            vi.statementStack.shift();
+        }
+        const value = this.test.resolveExpression(vi);
+        checkBooleanBranchCondition(value, () => this.test.tokens, vi.problems);
+    }
+}
+
+exports.DoStatement = DoStatement;

langserver/java/statementtypes/EmptyStatement.js

@@ -0,0 +1,6 @@
+const { Statement } = require("./Statement");
+
+class EmptyStatement extends Statement {
+}
+
+exports.EmptyStatement = EmptyStatement;

langserver/java/statementtypes/ExpressionStatement.js

@@ -0,0 +1,42 @@
+/**
+ * @typedef {import('../tokenizer').Token} Token
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ * @typedef {import('../expressiontypes/Expression').Expression} Expression
+ * @typedef {import('../source-types').SourceMethodLike} SourceMethodLike
+ */
+const { Statement } = require("./Statement");
+const { BinaryOpExpression } = require('../expressiontypes/BinaryOpExpression');
+const { MethodCallExpression } = require('../expressiontypes/MethodCallExpression');
+const { NewObject } = require('../expressiontypes/NewExpression');
+const { IncDecExpression } = require('../expressiontypes/IncDecExpression');
+const ParseProblem = require('../parsetypes/parse-problem');
+
+class ExpressionStatement extends Statement {
+    /**
+     * @param {SourceMethodLike} owner
+     * @param {ResolvedIdent} expression 
+     */
+    constructor(owner, expression) {
+        super(owner);
+        this.expression = expression;
+    }
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        // only method calls, new objects, increments and assignments are allowed as expression statements
+        const e = this.expression.variables[0];
+        let is_statement = e instanceof MethodCallExpression || e instanceof NewObject || e instanceof IncDecExpression;
+        if (e instanceof BinaryOpExpression) {
+            is_statement = e.op.kind === 'assignment-operator';
+        }
+        if (!is_statement) {
+            vi.problems.push(ParseProblem.Error(this.expression.tokens, `Statement expected`));
+        }
+        this.expression.resolveExpression(vi);
+    }
+}
+
+exports.ExpressionStatement = ExpressionStatement;

langserver/java/statementtypes/ForStatement.js

@@ -0,0 +1,55 @@
+/**
+ * @typedef {import('./Statement').Statement} Statement
+ * @typedef {import('../body-types').Local} Local
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ * @typedef {import('../tokenizer').Token} Token
+ */
+const { KeywordStatement } = require("./KeywordStatement");
+const { checkNonVarDeclStatement } = require('../statement-validater');
+const { Local, ResolvedIdent } = require('../body-types');
+
+class ForStatement extends KeywordStatement {
+    /** @type {ResolvedIdent[] | Local[]} */
+    init = null;
+    /** @type {ResolvedIdent} */
+    test = null;
+    /** @type {ResolvedIdent[]} */
+    update = null;
+    /** @type {ResolvedIdent} */
+    iterable = null;
+    /** @type {Statement} */
+    statement = null;
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        if (this.init) {
+            this.init.forEach(x => {
+                if (x instanceof ResolvedIdent) {
+                    x.resolveExpression(vi);
+                } else if (x instanceof Local) {
+                    if (x.init) {
+                        x.init.resolveExpression(vi);
+                    }
+                }
+            })
+        }
+        if (this.test) {
+            this.test.resolveExpression(vi);
+        }
+        if (this.update) {
+            this.update.forEach(e => e.resolveExpression(vi));
+        }
+        if (this.iterable) {
+            this.iterable.resolveExpression(vi);
+        }
+        if (this.statement) {
+            vi.statementStack.unshift('for');
+            checkNonVarDeclStatement(this.statement, vi);
+            vi.statementStack.shift();
+        }
+    }
+}
+
+exports.ForStatement = ForStatement;

langserver/java/statementtypes/IfStatement.js

@@ -0,0 +1,39 @@
+/**
+ * @typedef {import('./Statement').Statement} Statement
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ */
+const { KeywordStatement } = require("./KeywordStatement");
+const { checkBooleanBranchCondition } = require('../expression-resolver');
+const { checkNonVarDeclStatement } = require('../statement-validater');
+
+class IfStatement extends KeywordStatement {
+    /** @type {ResolvedIdent} */
+    test = null;
+    /** @type {Statement} */
+    statement = null;
+    /** @type {Statement} */
+    elseStatement = null;
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        if (this.test) {
+            const value = this.test.resolveExpression(vi);
+            checkBooleanBranchCondition(value, () => this.test.tokens, vi.problems);
+        }
+        if (this.statement) {
+            vi.statementStack.unshift('if');
+            checkNonVarDeclStatement(this.statement, vi);
+            vi.statementStack.shift();
+        }
+        if (this.elseStatement) {
+            vi.statementStack.unshift('else');
+            checkNonVarDeclStatement(this.elseStatement, vi);
+            vi.statementStack.shift();
+        }
+    }
+}
+
+exports.IfStatement = IfStatement;

langserver/java/statementtypes/InvalidStatement.js

@@ -0,0 +1,18 @@
+/**
+ * @typedef {import('../tokenizer').Token} Token
+ * @typedef {import('../source-types').SourceMethodLike} SourceMethodLike
+ */
+const { Statement } = require("./Statement");
+
+class InvalidStatement extends Statement {
+    /**
+     * @param {SourceMethodLike} owner
+     * @param {Token} token 
+     */
+    constructor(owner, token) {
+        super(owner);
+        this.token = token;
+    }
+}
+
+exports.InvalidStatement = InvalidStatement;

langserver/java/statementtypes/KeywordStatement.js

@@ -0,0 +1,22 @@
+/**
+ * @typedef {import('../tokenizer').Token} Token
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ * @typedef {import('../source-types').SourceMethodLike} SourceMethodLike
+ */
+const { Statement } = require("./Statement");
+
+/**
+ * A statement that begins with a keyword (if, do, while, etc)
+ */
+class KeywordStatement extends Statement {
+    /**
+     * @param {SourceMethodLike} owner
+     * @param {Token} keyword 
+     */
+    constructor(owner, keyword) {
+        super(owner);
+        this.keyword = keyword;
+    }
+}
+
+exports.KeywordStatement = KeywordStatement;

langserver/java/statementtypes/LocalDeclStatement.js

@@ -0,0 +1,35 @@
+/**
+ * @typedef {import('../tokenizer').Token} Token
+ * @typedef {import('../body-types').Local} Local
+ * @typedef {import('../body-types').Label} Label
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ * @typedef {import('../source-types').SourceType} SourceType
+ * @typedef {import('../source-types').SourceMethodLike} SourceMethodLike
+ */
+const { Statement } = require("./Statement");
+const ParseProblem = require('../parsetypes/parse-problem');
+const { checkAssignment } = require('../expression-resolver');
+
+class LocalDeclStatement extends Statement {
+    /**
+     * @param {SourceMethodLike} owner
+     * @param {Local[]} locals 
+     */
+    constructor(owner, locals) {
+        super(owner);
+        this.locals = locals;
+    }
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        this.locals.forEach(local => {
+            if (local.init) {
+                checkAssignment(vi, local.type, local.init);
+            }
+        });
+    }
+}
+
+exports.LocalDeclStatement = LocalDeclStatement;

langserver/java/statementtypes/ReturnStatement.js

@@ -0,0 +1,61 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ * @typedef {import('../body-types').ResolvedValue} ResolvedValue
+ * @typedef {import('../source-types').SourceMethodLike} SourceMethodLike
+ * @typedef {import('../tokenizer').Token} Token
+ */
+const { JavaType, PrimitiveType } = require('java-mti');
+const { KeywordStatement } = require("./KeywordStatement");
+const ParseProblem = require('../parsetypes/parse-problem');
+const { isTypeAssignable } = require('../expression-resolver');
+const { NumberLiteral } = require('../expressiontypes/literals/Number');
+const { LambdaType, MultiValueType } = require('../anys');
+
+class ReturnStatement extends KeywordStatement {
+    /** @type {ResolvedIdent} */
+    expression = null;
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        const method_return_type = vi.method.returnType;
+        if (!this.expression) {
+            if (method_return_type !== PrimitiveType.map.V) {
+                vi.problems.push(ParseProblem.Error(this.keyword, `Method must return a value of type '${method_return_type.fullyDottedTypeName}'`));
+            }
+            return;
+        }
+        if (method_return_type === PrimitiveType.map.V) {
+            vi.problems.push(ParseProblem.Error(this.expression.tokens, `void method cannot return a value`));
+            return;
+        }
+        const type = this.expression.resolveExpression(vi);
+        checkType(type, () => this.expression.tokens);
+
+        /**
+         * @param {ResolvedValue} type 
+         * @param {() => Token[]} tokens 
+         */
+        function checkType(type, tokens) {
+            if (type instanceof JavaType || type instanceof NumberLiteral) {
+                if (!isTypeAssignable(method_return_type, type)) {
+                    const expr_type = type instanceof NumberLiteral ? type.type : type;
+                    vi.problems.push(ParseProblem.Error(tokens(), `Incompatible types: expression of type '${expr_type.fullyDottedTypeName}' cannot be returned from a method of type '${method_return_type.fullyDottedTypeName}'`));
+                }
+            } else if (type instanceof MultiValueType) {
+                // ternary, eg. return x > 0 ? 1 : 2;
+                type.types.forEach(type => checkType(type, tokens));
+            } else if (type instanceof LambdaType) {
+                if (!isTypeAssignable(method_return_type, type)) {
+                    vi.problems.push(ParseProblem.Error(tokens(), `Incompatible types: lambda expression is not compatible with method type '${method_return_type.fullyDottedTypeName}'`));
+                }
+            } else {
+                vi.problems.push(ParseProblem.Error(tokens(), `'${method_return_type.fullyDottedTypeName}' type expression expected`));
+            }
+        }
+    }
+}
+
+exports.ReturnStatement = ReturnStatement;

langserver/java/statementtypes/Statement.js

@@ -0,0 +1,17 @@
+/**
+ * @typedef {import('../source-types').SourceMethodLike} SourceMethodLike
+ */
+
+class Statement {
+
+    /**
+     * @param {SourceMethodLike} owner 
+     */
+    constructor(owner) {
+        this.owner = owner;
+    }
+
+    validate(vi) {}
+}
+
+exports.Statement = Statement;

langserver/java/statementtypes/SwitchStatement.js

@@ -0,0 +1,70 @@
+/**
+ * @typedef {import('./Statement').Statement} Statement
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ * @typedef {import('../tokenizer').Token} Token
+ */
+const { JavaType, PrimitiveType } = require('java-mti');
+const { KeywordStatement } = require("./KeywordStatement");
+const ParseProblem = require('../parsetypes/parse-problem');
+const { isTypeAssignable } = require('../expression-resolver');
+const { NumberLiteral } = require('../expressiontypes/literals/Number');
+
+class SwitchStatement extends KeywordStatement {
+    /** @type {ResolvedIdent} */
+    test = null;
+    /** @type {(ResolvedIdent|boolean)[]} */
+    cases = [];
+    /** @type {{cases: (ResolvedIdent|boolean)[], statements: Statement[]} []} */
+    caseBlocks = [];
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        let test_type = null;
+        if (this.test) {
+            test_type = this.test.resolveExpression(vi);
+            if (test_type instanceof NumberLiteral) {
+                test_type = test_type.type;
+            }
+            if (test_type instanceof JavaType) {
+                if (!isTypeAssignable(vi.typemap.get('java/lang/String'), test_type)) {
+                    if (!isTypeAssignable(PrimitiveType.map.I, test_type)) {
+                        test_type = null;
+                    }
+                }
+            } else {
+                test_type = null;
+            }
+            if (!test_type) {
+                vi.problems.push(ParseProblem.Error(this.test.tokens, `Switch expression must be of type 'int' or 'java.lang.String'`));
+            }
+        }
+
+        vi.statementStack.unshift('switch');
+
+        this.caseBlocks.forEach(caseblock => {
+            caseblock.cases.forEach(c => {
+                if (typeof c === 'boolean') {
+                    // default case
+                    return;
+                }
+                const case_value = c.resolveExpression(vi);
+                if (case_value instanceof JavaType || case_value instanceof NumberLiteral) {
+                    if (test_type && !isTypeAssignable(test_type, case_value)) {
+                        const case_type = case_value instanceof JavaType ? case_value : case_value.type;
+                        vi.problems.push(ParseProblem.Error(c.tokens, `Incomparable types: expression of type '${case_type.fullyDottedTypeName}' is not comparable with type '${test_type.fullyDottedTypeName}'`));
+                    }
+                } else {
+                    vi.problems.push(ParseProblem.Error(c.tokens, `Expression expected`));
+                }
+            });
+            caseblock.statements.forEach(statement => statement.validate(vi));
+        })
+
+        vi.statementStack.shift();
+    }
+}
+
+exports.SwitchStatement = SwitchStatement;

langserver/java/statementtypes/SynchronizedStatement.js

@@ -0,0 +1,35 @@
+/**
+ * @typedef {import('./Statement').Statement} Statement
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ */
+const { CEIType } = require('java-mti');
+const { KeywordStatement } = require("./KeywordStatement");
+const ParseProblem = require('../parsetypes/parse-problem');
+
+class SynchronizedStatement extends KeywordStatement {
+    /** @type {ResolvedIdent} */
+    expression = null;
+    /** @type {Statement} */
+    statement = null;
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        if (this.expression) {
+            const value = this.expression.resolveExpression(vi);
+            // locks must be a reference type
+            if (!(value instanceof CEIType)) {
+                vi.problems.push(ParseProblem.Error(this.expression.tokens, `Lock expression must be a reference type`));
+            }
+        }
+        if (this.statement) {
+            vi.statementStack.unshift('synchronized');
+            this.statement.validate(vi);
+            vi.statementStack.shift();
+        }
+    }
+}
+
+exports.SynchronizedStatement = SynchronizedStatement;

langserver/java/statementtypes/ThrowStatement.js

@@ -0,0 +1,32 @@
+/**
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ */
+const { JavaType } = require('java-mti');
+const { KeywordStatement } = require("./KeywordStatement");
+const { isTypeAssignable } = require('../expression-resolver');
+const ParseProblem = require('../parsetypes/parse-problem');
+
+class ThrowStatement extends KeywordStatement {
+    /** @type {ResolvedIdent} */
+    expression = null;
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        if (!this.expression) {
+            return;
+        }
+        const throw_value = this.expression.resolveExpression(vi);
+        if (throw_value instanceof JavaType) {
+            if (!isTypeAssignable(vi.typemap.get('java/lang/Throwable'), throw_value)) {
+                vi.problems.push(ParseProblem.Error(this.expression.tokens, `throw expression does not inherit from java.lang.Throwable`));
+            }
+        } else {
+            vi.problems.push(ParseProblem.Error(this.expression.tokens, `Throwable expression expected`));
+        }
+    }
+}
+
+exports.ThrowStatement = ThrowStatement;

langserver/java/statementtypes/TryStatement.js

@@ -0,0 +1,45 @@
+/**
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ * @typedef {import('./Block').Block} Block
+ * @typedef {import('../body-types').Local} Local
+ */
+const { KeywordStatement } = require("./KeywordStatement");
+const { ResolvedIdent } = require('../body-types');
+const { Block } = require('./Block');
+
+class TryStatement extends KeywordStatement {
+    /** @type {(ResolvedIdent|Local[])[]} */
+    resources = [];
+    /** @type {Block} */
+    block = null;
+    catches = [];
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        this.resources.forEach(r => {
+            if (r instanceof ResolvedIdent) {
+                r.resolveExpression(vi);
+            }
+        });
+        
+        if (this.block) {
+            vi.statementStack.unshift('try');
+            this.block.validate(vi);
+            vi.statementStack.shift();
+        }
+
+        this.catches.forEach(c => {
+            if (c instanceof Block) {
+                // finally
+                c.validate(vi);
+            } else if (c.block) {
+                // catch block
+                c.block.validate(vi);
+            }
+        })
+    }
+}
+
+exports.TryStatement = TryStatement;

langserver/java/statementtypes/WhileStatement.js

@@ -0,0 +1,31 @@
+/**
+ * @typedef {import('./Statement').Statement} Statement
+ * @typedef {import('../body-types').ResolvedIdent} ResolvedIdent
+ * @typedef {import('../body-types').ValidateInfo} ValidateInfo
+ */
+const { KeywordStatement } = require("./KeywordStatement");
+const { checkBooleanBranchCondition } = require('../expression-resolver');
+
+class WhileStatement extends KeywordStatement {
+    /** @type {ResolvedIdent} */
+    test = null;
+    /** @type {Statement} */
+    statement = null;
+
+    /**
+     * @param {ValidateInfo} vi 
+     */
+    validate(vi) {
+        if (this.test) {
+            const value = this.test.resolveExpression(vi);
+            checkBooleanBranchCondition(value, () => this.test.tokens, vi.problems);
+        }
+        if (this.statement) {
+            vi.statementStack.unshift('while');
+            this.statement.validate(vi);
+            vi.statementStack.shift();
+        }
+    }
+}
+
+exports.WhileStatement = WhileStatement;