diff --git a/langserver/java/body-parser3.js b/langserver/java/body-parser3.js
index f26e1cc..a5064cf 100644
--- a/langserver/java/body-parser3.js
+++ b/langserver/java/body-parser3.js
@@ -1915,7 +1915,7 @@ function qualifiers(matches, tokens, locals, method, imports, typemap) {
                 tokens.inc();
                 let type_arguments = [];
                 if (!tokens.isValue('>')) {
-                    type_arguments = typeIdentList(tokens, method, imports, typemap);
+                    type_arguments = typeIdentList(tokens, method._owner, imports, typemap);
                     tokens.expectValue('>');
                 }
                 matches.types = matches.types.map(t => {
diff --git a/langserver/java/typeident.js b/langserver/java/typeident.js
index 8a001dc..4ea1b08 100644
--- a/langserver/java/typeident.js
+++ b/langserver/java/typeident.js
@@ -1,4 +1,4 @@
-const { ArrayType, JavaType, WildcardType } = require('java-mti');
+const { ArrayType, CEIType, JavaType, WildcardType } = require('java-mti');
 const { SourceMethod, SourceConstructor, SourceInitialiser } = require('./source-type');
 const ResolvedImport = require('./parsetypes/resolved-import');
 const { resolveTypeOrPackage, resolveNextTypeOrPackage } = require('./type-resolver');
@@ -12,16 +12,16 @@ const { AnyType } = require("./body-types");
 
  /**
  * @param {TokenList} tokens 
- * @param {SourceMC} method 
+ * @param {CEIType} scoped_type 
  * @param {ResolvedImport[]} imports
  * @param {Map<string,JavaType>} typemap 
  */
-function typeIdentList(tokens, method, imports, typemap) {
-    let type = typeIdent(tokens, method, imports, typemap);
+function typeIdentList(tokens, scoped_type, imports, typemap) {
+    let type = typeIdent(tokens, scoped_type, imports, typemap);
     const types = [type];
     while (tokens.current.value === ',') {
         tokens.inc();
-        type = typeIdent(tokens, method, imports, typemap);
+        type = typeIdent(tokens, scoped_type, imports, typemap);
         types.push(type);
     }
     return types;
@@ -29,18 +29,18 @@ function typeIdentList(tokens, method, imports, typemap) {
 
 /**
  * @param {TokenList} tokens 
- * @param {SourceMC} method 
+ * @param {CEIType} scoped_type 
  * @param {ResolvedImport[]} imports
  * @param {Map<string,JavaType>} typemap 
  */
-function typeIdent(tokens, method, imports, typemap) {
+function typeIdent(tokens, scoped_type, imports, typemap) {
     if (tokens.current.kind !== 'ident') {
         if (tokens.current.value === '?') {
-            return wildcardTypeArgument(tokens, method, imports, typemap);
+            return wildcardTypeArgument(tokens, scoped_type, imports, typemap);
         }
         return AnyType.Instance;
     }
-    let { types, package_name } = resolveTypeOrPackage(tokens.current.value, method._owner, imports, typemap);
+    let { types, package_name } = resolveTypeOrPackage(tokens.current.value, scoped_type, imports, typemap);
     tokens.inc();
     for (;;) {
         if (tokens.isValue('.')) {
@@ -50,7 +50,7 @@ function typeIdent(tokens, method, imports, typemap) {
             resolveNextTypeOrPackage(tokens.current.value, types, package_name, typemap);
         } else if (tokens.isValue('<')) {
             if (!tokens.isValue('>')) {
-                typeIdentList(tokens, method, imports, typemap);
+                typeIdentList(tokens, scoped_type, imports, typemap);
                 if (/>>>?/.test(tokens.current.value)) {
                     // we need to split >> and >>> into separate > tokens to handle things like List<Class<?>>
                     const new_tokens = tokens.current.value.split('').map((gt,i) => new Token(tokens.current.range.source, tokens.current.range.start + i, 1, 'comparison-operator'));
@@ -81,12 +81,12 @@ function typeIdent(tokens, method, imports, typemap) {
 
 /**
  * @param {TokenList} tokens 
- * @param {SourceMC} method 
+ * @param {CEIType} scoped_type 
  * @param {ResolvedImport[]} imports
  * @param {Map<string,JavaType>} typemap 
  * @returns {WildcardType}
  */
-function wildcardTypeArgument(tokens, method, imports, typemap) {
+function wildcardTypeArgument(tokens, scoped_type, imports, typemap) {
     tokens.expectValue('?');
     let bound = null;
     switch (tokens.current.value) {
@@ -96,7 +96,7 @@ function wildcardTypeArgument(tokens, method, imports, typemap) {
             tokens.inc();
             bound = {
                 kind,
-                type: typeIdent(tokens, method, imports, typemap),
+                type: typeIdent(tokens, scoped_type, imports, typemap),
             }
             break;
     }