From d869afe2faa6b297bccbab058830e675e01ac8bc Mon Sep 17 00:00:00 2001
From: Dave Holoway <adelphes@gmail.com>
Date: Thu, 18 Jun 2020 13:16:39 +0100
Subject: [PATCH] improve reporting of unresolved identifiers

---
 langserver/java/body-types.js                  |  2 ++
 langserver/java/expression-resolver.js         | 11 +++++------
 .../java/expressiontypes/MemberExpression.js   | 18 ++++++++++++++----
 3 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/langserver/java/body-types.js b/langserver/java/body-types.js
index 4266c1e..a5ad053 100644
--- a/langserver/java/body-types.js
+++ b/langserver/java/body-types.js
@@ -5,6 +5,7 @@
 const { JavaType, CEIType, ArrayType, Method } = require('java-mti');
 const { Token } = require('./tokenizer');
 const { AnyType, MethodType, TypeIdentType } = require('./anys');
+const ParseProblem = require('./parsetypes/parse-problem');
 
 
 class ResolvedIdent {
@@ -39,6 +40,7 @@ class ResolvedIdent {
         if (this.types[0]) {
             return new TypeIdentType(this.types[0]);
         }
+        ri.problems.push(ParseProblem.Error(this.tokens, `Unresolved identifier: ${this.source}`));
         return AnyType.Instance;
     }
 
diff --git a/langserver/java/expression-resolver.js b/langserver/java/expression-resolver.js
index 527260e..7721181 100644
--- a/langserver/java/expression-resolver.js
+++ b/langserver/java/expression-resolver.js
@@ -50,14 +50,13 @@ function checkTypeAssignable(variable_type, value_type, tokens, problems) {
         value_type.types.forEach(t => checkTypeAssignable(variable_type, t, tokens, problems));
         return;
     }
-    if (!(value_type instanceof JavaType)) {
+    if (value_type instanceof JavaType) {
+        if (!isTypeAssignable(variable_type, value_type)) {
+            problems.push(ParseProblem.Error(tokens(), `Incompatible types: Expression of type '${value_type.fullyDottedTypeName}' cannot be assigned to a variable of type '${variable_type.fullyDottedTypeName}'`));
+        }
         return;
     }
-    if (!isTypeAssignable(variable_type, value_type)) {
-        const t = tokens();
-        if (t.length || (t && !Array.isArray(t)))
-            problems.push(ParseProblem.Error(t, `Incompatible types: Expression of type '${value_type.fullyDottedTypeName}' cannot be assigned to a variable of type '${variable_type.fullyDottedTypeName}'`));
-    }
+    problems.push(ParseProblem.Error(tokens(), `Field, variable or method call expected`));
 }
 
 /**
diff --git a/langserver/java/expressiontypes/MemberExpression.js b/langserver/java/expressiontypes/MemberExpression.js
index 5ec0b80..5e8c9c4 100644
--- a/langserver/java/expressiontypes/MemberExpression.js
+++ b/langserver/java/expressiontypes/MemberExpression.js
@@ -5,8 +5,9 @@
  */
 const { Expression } = require("./Expression");
 const { CEIType } = require('java-mti');
-const { AnyType, MethodType } = require('../anys');
+const { AnyType, MethodType, TypeIdentType } = require('../anys');
 const { getTypeInheritanceList } = require('../expression-resolver');
+const ParseProblem = require('../parsetypes/parse-problem');
 
 class MemberExpression extends Expression {
     /**
@@ -24,11 +25,19 @@ class MemberExpression extends Expression {
      * @param {ResolveInfo} ri 
      */
     resolveExpression(ri) {
-        const type = this.instance.resolveExpression(ri);
-        if (!(type instanceof CEIType)) {
-            return AnyType.Instance;
+        let type = this.instance.resolveExpression(ri);
+        if (type instanceof TypeIdentType) {
+            // static member
+            type = type.type;
+        }
+        if (type instanceof AnyType) {
+            return type;
         }
         const ident = this.member.value;
+        if (!(type instanceof CEIType)) {
+            ri.problems.push(ParseProblem.Error(this.member, `Unresolved member: '${ident}'`));
+            return AnyType.Instance;
+        }
         const field = type.fields.find(f => f.name === ident);
         if (field) {
             return field.type;
@@ -45,6 +54,7 @@ class MemberExpression extends Expression {
         if (methods.size > 0) {
             return new MethodType([...methods.values()]);
         }
+        ri.problems.push(ParseProblem.Error(this.member, `Unresolved member: '${ident}' in type '${type.fullyDottedRawName}'`));
         return AnyType.Instance;
     }