diff --git a/langserver/java/body-types.js b/langserver/java/body-types.js
index 1fa7b45..82180ef 100644
--- a/langserver/java/body-types.js
+++ b/langserver/java/body-types.js
@@ -30,10 +30,10 @@ class AnyType extends JavaType {
      */
     constructor(label) {
         super("class", [], '');
-        super.simpleTypeName = label;
+        super.simpleTypeName = label || '<unknown type>';
     }
 
-    static Instance = new AnyType('<unknown type>');
+    static Instance = new AnyType('');
 
     get rawTypeSignature() {
         return 'U';
diff --git a/langserver/java/typeident.js b/langserver/java/typeident.js
index efc846d..4a02c5c 100644
--- a/langserver/java/typeident.js
+++ b/langserver/java/typeident.js
@@ -37,6 +37,7 @@ function typeIdentList(tokens, scope, imports, typemap) {
 function typeIdent(tokens, scope, imports, typemap, allow_array_qualifiers = true) {
     /** @type {JavaType[]} */
     let types = [], package_name = '';
+    const start_idx = tokens.idx;
     switch(tokens.current.kind) {
         case 'ident':
             ({ types, package_name } = resolveTypeOrPackage(tokens.current.value, scope, imports, typemap));
@@ -59,25 +60,29 @@ function typeIdent(tokens, scope, imports, typemap, allow_array_qualifiers = tru
             tokens.inc();
         } else if (tokens.isValue('<')) {
             genericTypeArgs(tokens, types, scope, imports, typemap);
-        } else if (allow_array_qualifiers && tokens.isValue('[')) {
-            let arrdims = 0;
-            for(;;) {
-                arrdims++;
-                tokens.expectValue(']');
-                if (!tokens.isValue('[')) {
-                    break;
-                }
-            }
-            if (!types[0]) {
-                types.push(AnyType.Instance);
-            }
-            types = types.map(t => new ArrayType(t, arrdims));
         } else {
             break;
         }
     }
 
-    return types[0] || AnyType.Instance;
+    if (!types[0]) {
+        const anytype = new AnyType(tokens.tokens.slice(start_idx, tokens.idx).map(t => t.source).join('').trim());
+        types.push(anytype);
+    }
+
+    if (allow_array_qualifiers && tokens.isValue('[')) {
+        let arrdims = 0;
+        for(;;) {
+            arrdims++;
+            tokens.expectValue(']');
+            if (!tokens.isValue('[')) {
+                break;
+            }
+        }
+        types = types.map(t => new ArrayType(t, arrdims));
+    }
+    
+    return types[0];
 }
 
 /**
diff --git a/langserver/java/validation/invalid-types.js b/langserver/java/validation/invalid-types.js
index a8ac6f4..64e0d85 100644
--- a/langserver/java/validation/invalid-types.js
+++ b/langserver/java/validation/invalid-types.js
@@ -1,16 +1,18 @@
 const { ModuleBlock, TypeDeclBlock } = require('../parser9');
 const ParseProblem = require('../parsetypes/parse-problem');
 const {SourceType} = require('../source-type');
-const {JavaType, CEIType, TypeArgument, UnresolvedType} = require('java-mti')
+const {JavaType, ArrayType, CEIType, TypeArgument, UnresolvedType} = require('java-mti');
+const { AnyType } = require('../body-types');
 
 /**
  * @param {JavaType} type 
  */
 function checkType(type, is_return_type, typeTokens, probs) {
-    if (type instanceof UnresolvedType) {
+    const typesig = type.typeSignature;
+    if (/^\[*U/.test(typesig)) {
+        probs.push(ParseProblem.Error(typeTokens, `Unresolved type '${type.label}'`))
         return;
     }
-    const typesig = type.typeSignature;
     if (typesig === 'V' && !is_return_type) {
         probs.push(ParseProblem.Error(typeTokens, `'void' is not a valid type for variables`))
     }