diff --git a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/internal/types/TypeInfo.java b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/internal/types/TypeInfo.java
index 32e4027..4e4d599 100644
--- a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/internal/types/TypeInfo.java
+++ b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/internal/types/TypeInfo.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
+ * Copyright (c) 2001, 2021 Oracle Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -9,10 +9,12 @@
  * 
  * Contributors:
  *     Oracle Corporation - initial API and implementation
+ *     Reto Weiss/Axon Ivy      Cache resolved types
  *******************************************************************************/
 package org.eclipse.jst.jsf.common.internal.types;
 
 import org.eclipse.jdt.core.IType;
+import org.eclipse.jst.jsf.common.util.JDTBeanIntrospector;
 import org.eclipse.jst.jsf.context.symbol.IBeanMethodSymbol;
 import org.eclipse.jst.jsf.context.symbol.IBeanPropertySymbol;
 
@@ -32,6 +34,7 @@
     private IType[] supertypes = null;
     private IType[] interfaceTypes = null;
     private String[] missingSupertypeNames = null;
+    private JDTBeanIntrospector beanIntrospector = null;
     
     /**Creates an empty TypeInfo object
      */
@@ -109,4 +112,11 @@
         this.missingSupertypeNames = missingSupertypeNames;
     }
     
+    public JDTBeanIntrospector getBeanIntrospector() {
+      return beanIntrospector;
+    }
+    
+    public void setBeanIntrospector(JDTBeanIntrospector beanIntrospector) {
+      this.beanIntrospector = beanIntrospector;
+    }
 }
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/internal/types/TypeInfoCache.java b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/internal/types/TypeInfoCache.java
index d7da0fe..9bcc991 100644
--- a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/internal/types/TypeInfoCache.java
+++ b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/internal/types/TypeInfoCache.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2009 Oracle Corporation and others.
+ * Copyright (c) 2001, 2021 Oracle Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -8,7 +8,8 @@
  * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
- *     Oracle Corporation - initial API and implementation
+ *     Oracle Corporation  - initial API and implementation
+ *     Reto Weiss/Axon Ivy - Cache resolved types
  *******************************************************************************/
 package org.eclipse.jst.jsf.common.internal.types;
 
@@ -36,6 +37,7 @@
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jst.jsf.common.JSFCommonPlugin;
+import org.eclipse.jst.jsf.common.util.JDTBeanIntrospector;
 import org.eclipse.jst.jsf.context.symbol.IBeanMethodSymbol;
 import org.eclipse.jst.jsf.context.symbol.IBeanPropertySymbol;
 
@@ -84,7 +86,7 @@
     public static void disposeInstance(final TypeInfoCache cache)
     {
         if (cache != null 
-                && cache != instance)        
+                && cache != instance)
         {
             JavaCore.removeElementChangedListener(cache);
             
@@ -181,6 +183,24 @@
         return methods;
     }
     
+
+    /**
+     * @param beanType
+     * @return cached bean introspector or null
+     */
+    public JDTBeanIntrospector getCachedBeanIntrospector(IType beanType)
+    {
+      if (beanType != null)
+      {
+          TypeInfo typeInfo = getTypeInfo(beanType);
+          if (typeInfo != null)
+          {
+              return typeInfo.getBeanIntrospector();
+          }
+      }
+      return null;
+    }
+    
     /**Returns the cached supertypes for a given type. Will return null if no supertypes
      * have been cached for this type or if the type/something it depends on has changed since
      * then.
@@ -189,18 +209,16 @@
      * @see TypeInfoCache#cacheSupertypesFor(IType)
      */
     public synchronized IType[] getCachedSupertypes(IType type) {
-        IType[] types = null;
-        
         if (type != null)
         {
             TypeInfo typeInfo = getTypeInfo(type);
             if (typeInfo != null)
             {
-                types = typeInfo.getSupertypes();
+                return typeInfo.getSupertypes();
             }
         }
         
-        return types;
+        return null;
     }
     
     /**Returns the cached implemented interfaces for a given type. Will return null if no interfaces
@@ -253,6 +271,22 @@
             }
         }
     }
+
+    /**
+     * Chaches the given bean introspector for the given type
+     * @param beanType
+     * @param beanIntrospector
+     */
+    public void cacheBeanIntrospector(IType beanType, JDTBeanIntrospector beanIntrospector)
+    {
+      if (beanType != null)
+      {
+          TypeInfo typeInfo = getOrCreateTypeInfo(beanType);
+          if (typeInfo != null) {
+              typeInfo.setBeanIntrospector(beanIntrospector);
+          }
+      }
+    }
     
     /**Caches the supertypes for the given type. The supertypes will be calculated (and also returned)
      * by this method.
@@ -601,5 +635,4 @@
             }
         }
     }
-
 }
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanIntrospector.java b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanIntrospector.java
index f5411ac..47616d9 100644
--- a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanIntrospector.java
+++ b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanIntrospector.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2010 Oracle Corporation.
+ * Copyright (c) 2007, 2021 Oracle Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -9,6 +9,7 @@
  *
  * Contributors:
  *    Cameron Bateman/Oracle - initial API and implementation
+ *    Reto Weiss/Axon Ivy      Cache resolved types
  *    
  ********************************************************************************/
 package org.eclipse.jst.jsf.common.util;
@@ -21,14 +22,13 @@
 import java.util.Map;
 import java.util.Map.Entry;
 
-import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.jdt.core.Flags;
 import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.ITypeHierarchy;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.Signature;
 import org.eclipse.jst.jsf.common.JSFCommonPlugin;
+import org.eclipse.jst.jsf.common.internal.types.TypeInfoCache;
 
 /**
  * A class that does bean introspection on a JDT IType
@@ -44,176 +44,242 @@
  * @author cbateman
  *
  */
-public class JDTBeanIntrospector 
+public class JDTBeanIntrospector
 {
-	private final static String GET_PREFIX = "get"; //$NON-NLS-1$
-	private final static String SET_PREFIX = "set"; //$NON-NLS-1$
-	private final static String IS_PREFIX = "is"; //$NON-NLS-1$
-	
-	private final IType 	_type;
-	private final HashMap<String, String> _resolvedSignatures;
+  private final static IType[] EMPTY_SUPER_TYPES = new IType[0];
+  private final static String GET_PREFIX = "get"; //$NON-NLS-1$
+  private final static String SET_PREFIX = "set"; //$NON-NLS-1$
+  private final static String IS_PREFIX = "is"; //$NON-NLS-1$
+  private final static IMethod[] EMTPY_METHODS = new IMethod[0];
 
-	/**
-	 * @param type
-	 */
-	public JDTBeanIntrospector(IType type)
-	{
-		_type = type;
-		_resolvedSignatures = new HashMap<String, String>();
-	}
-	
-	/**
-	 * @return an map of all properties with the property names
-     * as keys and the values being JDTBeanProperty objects representing
-     * the properties.
-	 */
-	public Map<String, JDTBeanProperty> getProperties()
-	{
-		_resolvedSignatures.clear();
+  private final IType type;
+  private final JDTTypeResolver typeResolver;
+  private IMethod[] methods;
+  private final IType[] superTypes;
 
-		final Map<String, JDTBeanProperty>   propertiesWorkingCopy = 
-		    new HashMap<String, JDTBeanProperty>();
-		final IMethod[] methods = getAllMethods();
-		
-		for (int i = 0; i < methods.length; i++)
-		{
-			final IMethod  method = methods[i];
-
-			try
-			{
-				processPropertyMethod(method, propertiesWorkingCopy);
-			}
-			catch (JavaModelException jme)
-			{
-				// log and then proceed to next method
-				JSFCommonPlugin.log(jme, "Error processing IMethod for bean property info"); //$NON-NLS-1$
-			}
-		}
-
-        final Map properties = new HashMap();
-        
-        for (Entry<String, JDTBeanProperty> entry : propertiesWorkingCopy.entrySet())
-        {
-            final String key = entry.getKey();
-            JDTBeanPropertyWorkingCopy  wcopy = (JDTBeanPropertyWorkingCopy) entry.getValue();
-            properties.put(key, wcopy.toValueObject());
-        }
-
-		return properties;
-	}
-
-	private void processPropertyMethod(IMethod method, Map<String, JDTBeanProperty> properties) throws JavaModelException
-	{
-		// to be a bean method, it must not a constructor, must be public
-		// and must not be static
-		if (!method.isConstructor()
-				&& ( Flags.isPublic(method.getFlags())
-				        || _type.isInterface())
-				&& !Flags.isStatic(method.getFlags()))
-		{
-			final String methodName = method.getElementName();
-			final String returnType = method.getReturnType();
-			
-			// either starts with get or is boolean and starts with is
-			
-			// is access must start with 'is', have a boolean return type and no parameters
-			final boolean  startsWithIs = methodName.startsWith(IS_PREFIX) 
-					&& Signature.SIG_BOOLEAN.equals(returnType)
-					&& method.getNumberOfParameters() == 0
-                    && methodName.length() > IS_PREFIX.length();
-			
-			// get accessor must start with 'get', have no parameters and return non-void
-			final boolean  startsWithGet = (methodName.startsWith(GET_PREFIX)
-											&& method.getNumberOfParameters() == 0)
-											&& !Signature.SIG_VOID.equals(returnType)                    
-                                            && methodName.length() > GET_PREFIX.length();
-			
-			// mutator must start with 'set' and have one parameter and a void return type
-			final boolean  startsWithSet = methodName.startsWith(SET_PREFIX)
-											&& method.getNumberOfParameters() == 1
-											&& Signature.SIG_VOID.equals(returnType)
-                                            && methodName.length() > SET_PREFIX.length();
-
-			if (startsWithGet || startsWithSet || startsWithIs)
-			{
-				final String propertyName = 
-					Introspector.decapitalize(methodName.substring(startsWithIs ? 2 : 3));
-
-				JDTBeanPropertyWorkingCopy workingCopy = 
-					(JDTBeanPropertyWorkingCopy) properties.get(propertyName);
-
-				if (workingCopy == null)
-				{
-					workingCopy = new JDTBeanPropertyWorkingCopy(_type, _resolvedSignatures);
-					properties.put(propertyName, workingCopy);
-				}
-
-				if  (startsWithIs)
-				{
-					workingCopy.setIsGetter(method);
-				}
-				else if (startsWithGet)
-				{
-					workingCopy.setGetter(method);
-				}
-				else if (startsWithSet)
-				{
-					workingCopy.addSetter(method);
-				}
-			}
-		}
-	}
-
-	/**
-	 * @return all methods for the type including inherited ones
-	 */
-	public IMethod[] getAllMethods()
-	{
-		IMethod[] methods = new IMethod[0];
-		
-		try
-		{
-            // type not resolved so don't proceed
-            if (_type != null)
-            {
-	            // TODO: type hierarchy is potentially expensive, should
-	            // cache once and listen for changes
-	            ITypeHierarchy  hierarchy = _type.newSupertypeHierarchy(new NullProgressMonitor());
-	            
-				methods = getAllMethods(hierarchy, _type);
-            }
-		}
-		catch(JavaModelException jme)
-		{
-            JSFCommonPlugin.log(jme, "Error getting type information for bean"); //$NON-NLS-1$
-		}
-
-		return methods;
-	}
-
-    /**
-     * @param typeHierarchy
-     * @param type
-     * @return all methods of the type and it's super types
-     */
-    private static IMethod[] getAllMethods(final ITypeHierarchy typeHierarchy, final IType type)
+  /**
+   * @param type
+   * @return cached JDT bean introspector for the given type
+   */
+  public static JDTBeanIntrospector forType(IType type)
+  {
+    TypeInfoCache cache = TypeInfoCache.getInstance();
+    JDTBeanIntrospector beanIntrospector = cache.getCachedBeanIntrospector(type);
+    if (beanIntrospector != null)
     {
-        final List<IMethod>   methods = new ArrayList<IMethod>();
-        final IType[] superTypes = typeHierarchy.getAllSuperclasses(type);
-        final IType[] closure = new IType[superTypes.length+1];
-        closure[0] = type;
-        System.arraycopy(superTypes, 0, closure, 1, superTypes.length);
-        
-        for (int i = 0; i < closure.length; i++)
-        {
-            try {
-                final IType superType = closure[i];
-                methods.addAll(Arrays.asList(superType.getMethods()));
-            } catch (JavaModelException e) {
-                JSFCommonPlugin.log(e, "Error getting super type information for bean"); //$NON-NLS-1$
-            }
-        }
-            
-        return methods.toArray(new IMethod[methods.size()]);
+      return beanIntrospector;
     }
+    IType[] superTypes = cache.getCachedSupertypes(type);
+    if (superTypes == null)
+    {
+      superTypes = cache.cacheSupertypesFor(type);
+    }
+    beanIntrospector = new JDTBeanIntrospector(type, superTypes);
+    cache.cacheBeanIntrospector(type, beanIntrospector);
+    return beanIntrospector;
+  }
+  
+  /**
+   * @param type
+   */
+  private JDTBeanIntrospector(IType type, IType[] superTypes)
+  {
+    this.type = type;
+    this.superTypes = superTypes;
+    if (superTypes == null)
+    {
+      superTypes = EMPTY_SUPER_TYPES;
+    }
+      
+    this.typeResolver = new JDTTypeResolver(type, superTypes);
+  }
+
+  /**
+   * @return an map of all properties with the property names as keys and the
+   *         values being JDTBeanProperty objects representing the properties.
+   */
+  public Map<String, JDTBeanProperty> getProperties()
+  {
+    final Map<String, JDTBeanPropertyWorkingCopy> propertiesWorkingCopy = new HashMap<String, JDTBeanPropertyWorkingCopy>();
+    final IMethod[] mthds = methods();
+
+    for (int i = 0; i < mthds.length; i++)
+    {
+      try
+      {
+        processPropertyMethod(mthds[i], propertiesWorkingCopy);
+      }
+      catch (JavaModelException jme)
+      {
+        // log and then proceed to next method
+        JSFCommonPlugin.log(jme, "Error processing IMethod for bean property info"); //$NON-NLS-1$
+      }
+    }
+
+    final Map<String, JDTBeanProperty> properties = new HashMap<String, JDTBeanProperty>();
+
+    for (Entry<String, JDTBeanPropertyWorkingCopy> entry : propertiesWorkingCopy.entrySet())
+    {
+      final String key = entry.getKey();
+      JDTBeanPropertyWorkingCopy wcopy = entry.getValue();
+      properties.put(key, wcopy.toValueObject());
+    }
+
+    return properties;
+  }
+
+  private void processPropertyMethod(IMethod method, Map<String, JDTBeanPropertyWorkingCopy> properties)
+          throws JavaModelException
+  {
+    // to be a bean method, it must not a constructor, must be public
+    // and must not be static
+    if (!method.isConstructor()
+            && (Flags.isPublic(method.getFlags())
+                    || type.isInterface())
+            && !Flags.isStatic(method.getFlags()))
+    {
+      final String methodName = method.getElementName();
+      final String returnType = method.getReturnType();
+
+      // either starts with get or is boolean and starts with is
+
+      // is access must start with 'is', have a boolean return type and no
+      // parameters
+      final boolean startsWithIs = methodName.startsWith(IS_PREFIX)
+              && Signature.SIG_BOOLEAN.equals(returnType)
+              && method.getNumberOfParameters() == 0
+              && methodName.length() > IS_PREFIX.length();
+
+      // get accessor must start with 'get', have no parameters and return
+      // non-void
+      final boolean startsWithGet = (methodName.startsWith(GET_PREFIX)
+              && method.getNumberOfParameters() == 0)
+              && !Signature.SIG_VOID.equals(returnType)
+              && methodName.length() > GET_PREFIX.length();
+
+      // mutator must start with 'set' and have one parameter and a void return
+      // type
+      final boolean startsWithSet = methodName.startsWith(SET_PREFIX)
+              && method.getNumberOfParameters() == 1
+              && Signature.SIG_VOID.equals(returnType)
+              && methodName.length() > SET_PREFIX.length();
+
+      if (startsWithGet || startsWithSet || startsWithIs)
+      {
+        final String propertyName = Introspector.decapitalize(methodName.substring(startsWithIs ? 2 : 3));
+
+        JDTBeanPropertyWorkingCopy workingCopy = properties.get(propertyName);
+
+        if (workingCopy == null)
+        {
+          workingCopy = new JDTBeanPropertyWorkingCopy(type, typeResolver, propertyName);
+          properties.put(propertyName, workingCopy);
+        }
+
+        if (startsWithIs)
+        {
+          workingCopy.setIsGetter(method);
+        }
+        else if (startsWithGet)
+        {
+          workingCopy.setGetter(method);
+        }
+        else if (startsWithSet)
+        {
+          workingCopy.addSetter(method);
+        }
+      }
+    }
+  }
+
+  /**
+   * @return methods
+   */
+  public JDTBeanMethod[] getMethods()
+  {
+    List<JDTBeanMethod> beanMethods = new ArrayList<JDTBeanMethod>();
+    for (IMethod method : methods())
+    {
+      JDTBeanMethod beanMethod = toBeanMethod(method);
+      if (beanMethod != null)
+      {
+        beanMethods.add(beanMethod);
+      }
+    }
+    return beanMethods.toArray(new JDTBeanMethod[beanMethods.size()]);
+  }
+  
+  private JDTBeanMethod toBeanMethod(IMethod method)
+  {
+    try
+    {
+      String resMethodSigErased = typeResolver.resolveMethodEraseTypeParams(method.getSignature());
+      String resMethodSigUnerased = typeResolver.resolveMethodKeepTypeParams(method.getSignature());
+      return new JDTBeanMethod(method, resMethodSigErased, resMethodSigUnerased);
+    }
+    catch(JavaModelException jme)
+    {
+      // log and then proceed to next method
+      JSFCommonPlugin.log(jme, "Error processing IMethod for bean method info"); //$NON-NLS-1$
+      return null;
+    }
+  }
+  
+  /**
+   * @return all methods for the type including inherited ones
+   */
+  private IMethod[] methods()
+  {
+    // type not resolved so don't proceed
+    if (type == null)
+    {
+      return EMTPY_METHODS;
+    }
+    if (methods == null)
+    {
+      methods = allMethods();
+    }
+    return methods;
+  }
+
+  /**
+   * @param typeHierarchy
+   * @param type
+   * @return all methods of the type and it's super types
+   */
+  private IMethod[] allMethods()
+  {
+    final List<IMethod> allMethods = new ArrayList<IMethod>();
+    final IType[] closure = new IType[superTypes.length + 1];
+    closure[0] = type;
+    System.arraycopy(superTypes, 0, closure, 1, superTypes.length);
+
+    for (IType t : closure)
+    {
+      try
+      {
+        allMethods.addAll(Arrays.asList(t.getMethods()));
+      }
+      catch (JavaModelException e)
+      {
+        JSFCommonPlugin.log(e, "Error getting super type information for bean"); //$NON-NLS-1$
+      }
+    }
+
+    return allMethods.toArray(new IMethod[allMethods.size()]);
+  }
+
+  /**
+   * @param simpleName simple type name
+   * @return full qualified type name or null
+   */
+  public String resolveFullQualifiedTypeName(String simpleName)
+  {
+    IType resolvedType = typeResolver.resolveTypeName(simpleName);
+    if (resolvedType == null)
+    {
+      return null;
+    }
+    return resolvedType.getFullyQualifiedName();
+  }
 }
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanMethod.java b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanMethod.java
new file mode 100644
index 0000000..9d1edbd
--- /dev/null
+++ b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanMethod.java
@@ -0,0 +1,131 @@
+/*******************************************************************************
+ * Copyright (c) 2020, 2021 Axon Ivy.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Reto Weiss/Axon Ivy      Cache resolved types
+ *    
+ ********************************************************************************/
+package org.eclipse.jst.jsf.common.util;
+
+
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.Signature;
+
+/**
+ * Represents a single bean method backed by JDT data
+ * @author rwei
+ * @since 27.11.2020
+ */
+public class JDTBeanMethod
+{
+  private final IMethod method;
+  private final String resolvedMethodSignatureErased;
+  private final String resolvedMethodSignatureUnerased;
+
+  JDTBeanMethod(IMethod method, String resolvedMethodSignatureErased, String resolvedMethodSignatureUnerased)
+  {
+    this.method = method;
+    this.resolvedMethodSignatureErased = resolvedMethodSignatureErased;
+    this.resolvedMethodSignatureUnerased = resolvedMethodSignatureUnerased;
+  }
+  
+  /**
+   * @return type that declares this method
+   */
+  public IType getDeclaringType()
+  {
+    return method.getDeclaringType();
+  }
+
+  /**
+   * @return jdt method that is behind this bean method
+   */
+  public IMethod getMethod()
+  {
+    return method;
+  }
+
+  /**
+   * @return method name
+   */
+  public String getElementName()
+  {
+    return method.getElementName();
+  }
+
+  /**
+   * @return true if method is a constructor
+   * @throws JavaModelException
+   */
+  public boolean isConstructor() throws JavaModelException
+  {
+    return method.isConstructor();
+  }
+
+  /**
+   * @return flags
+   * @throws JavaModelException
+   */
+  public int getFlags() throws JavaModelException
+  {
+    return method.getFlags();
+  }
+
+  /**
+   * @return method signature resolved (e.g. L signatures only no unresolved signatures with Q) and erased (no type parameters) 
+   */
+  public String getResolvedSignatureErased()
+  {
+    return resolvedMethodSignatureErased;
+  }
+
+  /**
+   * @return parameters types unresolved (e.g. may contain Q signatures) and unerased (with type parameters)
+   */
+  public String[] getUnresolvedParameterTypesUnerased()
+  {
+    return method.getParameterTypes();
+  }
+  
+  /**
+   * @return paramters types resolved (e.g. L signatures only no unresolved signatures with Q) and unerased (with type parameters)
+   */
+  public String[] getResolvedParameterTypesUnerased()
+  {
+    return Signature.getParameterTypes(resolvedMethodSignatureUnerased);
+  }
+
+  /**
+   * @return returns type resolved (e.g. L signatures only no unresolved signatures with Q) and unerased (with type parameters)
+   */
+  public String getResolvedReturnTypeUnerased() 
+  {
+    return Signature.getReturnType(resolvedMethodSignatureUnerased);
+  }
+  
+  /**
+   * @return return type unresolved (e.g Q signatures) and unerased (with type parameters)
+   * @throws JavaModelException
+   */
+  public String getUnresolvedReturnTypeUnerased() throws JavaModelException
+  {
+    return method.getReturnType();
+  }
+  
+  @Override
+  public String toString()
+  {
+    return "JDTBeanMethod [name="+getElementName()+ //$NON-NLS-1$
+            "erasedSignature="+resolvedMethodSignatureErased+ //$NON-NLS-1$
+            "unerasedSignature="+resolvedMethodSignatureUnerased+ //$NON-NLS-1$
+            "]"; //$NON-NLS-1$
+  }
+}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanProperty.java b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanProperty.java
index ec3d49d..3b26475 100644
--- a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanProperty.java
+++ b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanProperty.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2009 Oracle Corporation.
+ * Copyright (c) 2007, 2021 Oracle Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -9,18 +9,16 @@
  *
  * Contributors:
  *    Cameron Bateman/Oracle - initial API and implementation
+ *    Reto Weiss/Axon Ivy      Cache resolved types
  *    
  ********************************************************************************/
 package org.eclipse.jst.jsf.common.util;
 
-import java.util.ArrayList;
 import java.util.List;
 
 import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.Signature;
-import org.eclipse.jst.jsf.common.JSFCommonPlugin;
 
 /**
  * Represents a single bean property backed by JDT data
@@ -30,226 +28,125 @@
  * @author cbateman
  *
  */
-public class JDTBeanProperty 
+public class JDTBeanProperty
 {
-	/**
-	 * the IMethod for the accessor  (either is or get)
-	 */
-	private IMethod   _getter;
-	
-	/**
-	 * the IMethod for a "set" accessor method
-	 */
-	private IMethod   _setter;
+  private final IType type;
+  private final String typeSignature;
+  private final List<String> typeParameterSignatures;
+  private final IMethod getter;
+  private final IMethod setter;
+  private final String propertyName;
 
-	/**
-	 * The IType that this property belongs to
-	 */
-	protected final IType    _type;
-    
-    /**
-     * @param type
-     */
-    protected JDTBeanProperty(IType type)
-    {
-        _type = type;
-    }
+  JDTBeanProperty(String propertyName, IType type, String typeSignature, List<String> typeParameterSignatures, IMethod getter, IMethod setter)
+  {
+    this.propertyName = propertyName;
+    this.type = type;
+    this.typeSignature = typeSignature;
+    this.typeParameterSignatures = typeParameterSignatures;
+    this.getter = getter;
+    this.setter = setter;
+  }
 
-    /**
-	 * @return true if this property is readable
-	 */
-	public boolean isReadable()
-	{
-		return  _getter != null;
-	}
-	
-	/**
-	 * @return true if this property is writable
-	 */
-	public boolean isWritable()
-	{
-		return _setter != null;
-	}
-	
-	
-	/**
-	 * @return the get accessor IMethod or null if none
-	 */
-	public IMethod getGetter() {
-		return _getter;
-	}
+  /**
+   * @return true if property can be read
+   */
+  public boolean isReadable()
+  {
+    return getter != null;
+  }
 
-	
-	
-	/**
-	 * Set the get accessor IMethod
-	 * @param getter -- may be null to indicate none
-	 */
-	void setGetter(IMethod getter) {
-		_getter = getter;
-	}
+  /**
+   * @return true if property can be written
+   */
+  public boolean isWritable()
+  {
+    return setter != null;
+  }
 
+  /**
+   * @return JDT getter method
+   */
+  public IMethod getGetter()
+  {
+    return getter;
+  }
 
-	/**
-	 * @return the set mutator IMethod or null if none
-	 */
-	public IMethod getSetter() {
-		return _setter;
-	}
+  /**
+   * @return JDT setter metod
+   */
+  public IMethod getSetter()
+  {
+    return setter;
+  }
 
-	/**
-	 * @param setter
-	 */
-	void setSetter(IMethod setter) {
-		_setter = setter;
-	}
-	
-    /**
-     * @return the IType for this property's type or null if it
-     * cannot determined.  Note that null does not necessarily indicate an error
-     * since some types like arrays of things do not have corresponding JDT IType's
-     * If typeSignature represents an array, the base element IType is returned
-     * if possible
-     */
-    public IType getType()
-    {
-        final String typeSignature = Signature.getElementType(getTypeSignature());
-        return TypeUtil.resolveType(_type, typeSignature);
-    }
-	
-    /**
-     * @return the number of array nesting levels in typeSignature.
-     * Returns 0 if not an array.
-     */
-    public int getArrayCount()
-    {
-    	final String sig = getTypeSignature();
-    	if (sig == null)
-    		return 0;
-        return Signature.getArrayCount(sig);
-    }
-    
-    /**
-     * @return true if property is an enum type, false otherwise or if cannot be resolved
-     */
-    public boolean isEnumType()
-    {
-        return TypeUtil.isEnumType(getType());
-    }
-    
-	/**
-	 * Fully equivalent to:
-	 * 
-	 * getTypeSignature(true)
-	 * 
-	 * @return the fully resolved (if possible) type signature for
-     * the property or null if unable to determine.
-     * 
-     * NOTE: this is the "type erasure" signature, so any type parameters
-     * will be removed and only the raw type signature will be returned.
-	 */
-	public String getTypeSignature()
-    {
-	    return getTypeSignature(true);
-    }
-	
-	
-    /**
-     * @param eraseTypeParameters if true, the returned type has type parameters
-     * erased. If false, template types are resolved. 
-     * 
-     * @see org.eclipse.jst.jsf.common.util.TypeUtil#resolveTypeSignature(IType, String, boolean)
-     * for more information on how specific kinds of unresolved generics are resolved
-     * 
-     * @return the fully resolved (if possible) type signature for
-     * the property or null if unable to determine.
-     */
-    public String getTypeSignature(boolean eraseTypeParameters)
-    {
-        try
-        {
-            String unResolvedSig = getUnresolvedType();
-            return TypeUtil.resolveTypeSignature(_type, unResolvedSig, eraseTypeParameters);
-        }
-        catch (JavaModelException jme)
-        {
-            JSFCommonPlugin.log(jme, "Error resolving bean property type signature"); //$NON-NLS-1$
-            return null;
-        }
-    }
-    
-	/**
-	 * For example, if this property was formed from: List<String> getListOfStrings()
-	 * then the list would consist of the signature "Ljava.lang.String;".  All 
-	 * nested type paramters are resolved
-	 * 
-     * @see org.eclipse.jst.jsf.common.util.TypeUtil#resolveTypeSignature(IType, String, boolean)
-     * for more information on how specific kinds of unresolved generics are resolved
-	 * 
-	 * @return a list of type signatures (fully resolved if possible)
-	 * of this property's bounding type parameters.
-	 */
-	public List<String> getTypeParameterSignatures()
-	{
-	    List<String>  signatures = new ArrayList<String>();
-	    
-	    try
-	    {
-	        final String[] typeParameters = Signature.getTypeArguments(getUnresolvedType());
-	        //System.err.println(getUnresolvedType());
-	        for (String parameter : typeParameters)
-	        {
-	            //System.out.println(parameter);
-	            signatures.add(TypeUtil.resolveTypeSignature(_type, parameter, false));
-	        }
-	    }
-	    catch (JavaModelException jme)
-	    {
-            JSFCommonPlugin.log(jme, "Error resolving bean property type signature"); //$NON-NLS-1$
-            // fall-through and return empty array
-	    }
+  /**
+   * @return the IType for this property's type or null if it cannot determined.
+   *         Note that null does not necessarily indicate an error since some
+   *         types like arrays of things do not have corresponding JDT IType's
+   *         If typeSignature represents an array, the base element IType is
+   *         returned if possible
+   */
+  public IType getType()
+  {
+    return type;
+  }
 
-	    return signatures;
-	}
+  /**
+   * @return the number of array nesting levels in typeSignature. Returns 0 if
+   *         not an array.
+   */
+  public int getArrayCount()
+  {
+    final String sig = getTypeSignature();
+    if (sig == null)
+      return 0;
+    return Signature.getArrayCount(sig);
+  }
 
-//	public Map<String, String> getTypeParameterSignatureMap()
-//	{
-//	    Map<String, String>  signatures = new HashMap<String, String>();
-//        
-//        try
-//        {
-//            final String[] typeParameters = Signature.getTypeArguments(getUnresolvedType());
-//            
-//            for (String parameter : typeParameters)
-//            {
-//                signatures.add(TypeUtil.resolveTypeSignature(_type, parameter, false));
-//            }
-//        }
-//        catch (JavaModelException jme)
-//        {
-//            JSFCommonPlugin.log(jme, "Error resolving bean property type signature"); //$NON-NLS-1$
-//            // fall-through and return empty array
-//        }
-//
-//        return signatures;
-//	}
-	
-    private String getUnresolvedType() throws JavaModelException
-    {
-        String   typeSig = null;
-        
-        // first decide which method to use; getter always gets precendence
-        if (_getter != null)
-        {
-            typeSig = _getter.getReturnType();
-        }
-        // TODO: if no getter or setter could we have been created?
-        // use setter
-        else
-        {
-            typeSig = _setter.getParameterTypes()[0];
-        }
-        
-        return typeSig;
-    }
+  /**
+   * @return true if property is an enum type, false otherwise or if cannot be
+   *         resolved
+   */
+  public boolean isEnumType()
+  {
+    return TypeUtil.isEnumType(getType());
+  }
+
+  /**
+   * Fully equivalent to:
+   * 
+   * getTypeSignature(true)
+   * 
+   * @return the fully resolved (if possible) type signature for the property or
+   *         null if unable to determine.
+   * 
+   *         NOTE: this is the "type erasure" signature, so any type parameters
+   *         will be removed and only the raw type signature will be returned.
+   */
+  public String getTypeSignature()
+  {
+    return typeSignature;
+  }
+
+  /**
+   * For example, if this property was formed from: List<String>
+   * getListOfStrings() then the list would consist of the signature
+   * "Ljava.lang.String;". All nested type paramters are resolved
+   * 
+   * @return a list of type signatures (fully resolved if possible) of this
+   *         property's bounding type parameters.
+   */
+  public List<String> getTypeParameterSignatures()
+  {
+    return typeParameterSignatures;
+  }
+  
+  @Override
+  public String toString()
+  {    
+    return "JDTBeanProperty [name="+propertyName+ //$NON-NLS-1$
+           " typeSignature="+typeSignature+ //$NON-NLS-1$
+           " typeParameterSignatures "+typeParameterSignatures+ //$NON-NLS-1$
+           "]";  //$NON-NLS-1$
+  }
 }
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanPropertyWorkingCopy.java b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanPropertyWorkingCopy.java
index 14ef80f..aa06b55 100644
--- a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanPropertyWorkingCopy.java
+++ b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTBeanPropertyWorkingCopy.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2010 Oracle Corporation and others.
+ * Copyright (c) 2001, 2021 Oracle Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -9,18 +9,19 @@
  * 
  * Contributors:
  *     Oracle Corporation - initial API and implementation
+ *     Reto Weiss/Axon Ivy	Cache resolved types
  *******************************************************************************/
 package org.eclipse.jst.jsf.common.util;
 
 import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
-import java.util.Map;
 
 import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.Signature;
 import org.eclipse.jst.jsf.common.JSFCommonPlugin;
 
 /**
@@ -31,165 +32,154 @@
  * @author cbateman
  *
  */
-public class JDTBeanPropertyWorkingCopy extends JDTBeanProperty 
+public class JDTBeanPropertyWorkingCopy
 {
-	private final List		_setters;
-	
-	/**
-	 * the IMethod for the boolean "is" accessor method
-	 */
-	private IMethod        _isGetter;
+  private final List<IMethod> setters = new ArrayList<IMethod>();
+  private IMethod isGetter;
+  private IMethod getter;
+  private final IType type;
+  private final JDTTypeResolver typeResolver;
+  private final String propertyName;
 
-	private final Map<String, String> _resolvedSignatureMap;
-	
-	/**
-	 * @param type
-	 * @param resolvedSignatureMap
-	 */
-	public JDTBeanPropertyWorkingCopy(IType type, Map<String, String> resolvedSignatureMap)
-	{
-		super(type);
-		_setters = new ArrayList();
-		_resolvedSignatureMap = resolvedSignatureMap;
-	}
-	/**
-	 * Constructor
-	 * @param type 
-	 */
-	public JDTBeanPropertyWorkingCopy(IType type)
-	{
-        super(type);
-		_setters = new ArrayList();
-		_resolvedSignatureMap = new HashMap<String, String>();
-	}
-	
-	/**
-	 * @return the bean properties spawned from this working copy
-	 * Normally, there is only one property in the array, however,
-	 * since this working copy represents all properties with the same
-	 * name, there could be multiple properties since setters can
-	 * be overloaded by name and could result in zero or one readable
-	 * properties plus zero or more write-only properties with the same
-	 * name.  I can't see anywhere in the spec that covers this 
-	 * boundary case
-	 */
-	public JDTBeanProperty toValueObject()
-	{
-		// if the isGetter is present that it takes precedence
-		// over the the normal getter
-		IMethod  getter = getIsGetter() != null ? 
-							getIsGetter() : getGetter();
-		IMethod  matchedSetter = null;
+  /**
+   * @param type
+   * @param typeResolver
+   * @param propertyName 
+   */
+  public JDTBeanPropertyWorkingCopy(IType type, JDTTypeResolver typeResolver, String propertyName)
+  {
+    this.type = type;
+    this.typeResolver = typeResolver;
+    this.propertyName = propertyName;
+  }
 
-		if (getter != null)
-		{
-			matchedSetter = determineMatchedSetter(getter);
-		}
-		// if there's no getter than pick any setter: there
-		// are bigger problem when there's no getter than
-		// ambiguous setters
-		else if (_setters.size() > 0)
-		{
-			matchedSetter = (IMethod) _setters.get(0);
-		}
-		
-		JDTBeanProperty beanProp = new JDTBeanProperty(_type);
-		beanProp.setGetter(getter);
-		beanProp.setSetter(matchedSetter);
-		return beanProp;
-		
-	}
-	
-	private IMethod determineMatchedSetter(IMethod getter)
-	{
-		IMethod matchedSetter = null;
-		
-		// if there are no setters, there is no point in proceeding
-		if (_setters.size() < 1)
-		{
-			return null;
-		}
+  /**
+   * @param getter
+   */
+  public void setGetter(IMethod getter)
+  {
+    this.getter = getter;
+  }
 
-		try
-		{
-			final String getterSig = getResolvedSignature(_type, getter.getReturnType());
-			FIND_MATCHING_SETTER:for 
-				(final Iterator it = _setters.iterator(); it.hasNext();)
-			{
-				final IMethod  setter = (IMethod) it.next();
-				assert (setter.getNumberOfParameters() == 1);
-				final String paramSig = 
-					getResolvedSignature
-						(_type,setter.getParameterTypes()[0]);
-				
-				if (paramSig.equals(getterSig))
-				{
-					// we've found our match since only one
-					// setter with the same name as the getter
-					// can have the same matching type for a
-					// single arg method
-					matchedSetter = setter;
-					break FIND_MATCHING_SETTER;
-				}
-			}
-		}
-		catch (JavaModelException jme)
-		{
-            JSFCommonPlugin.log(jme, "Error determining getter return type, bean properties analysis may be inaccurate"); //$NON-NLS-1$
-		}
+  /**
+   * @param isGetter
+   */
+  public void setIsGetter(IMethod isGetter)
+  {
+    this.isGetter = isGetter;
+  }
 
-		return matchedSetter;
-	}
-	
-	//@Override
-	public void setGetter(IMethod getter) {
-		super.setGetter(getter);
-	}
-
-	/**
-	 * @param isGetter
-	 */
-	public void setIsGetter(IMethod isGetter) {
-		_isGetter = isGetter;
-	}
-
-	/**
-	 * @param setter
-	 */
-	public void addSetter(IMethod setter) {
-        if (setter != null
-                && setter.getNumberOfParameters() == 1)
-        {
-            _setters.add(setter);
-        }
-	}
-
-    /**
-     * Not supported on working copy.  This is synthetically generated
-     * on toValueObject()
-     * @return nothing; throws exception
-     */
-    public final IMethod getSetter()
+  /**
+   * @param setter
+   */
+  public void addSetter(IMethod setter)
+  {
+    if (setter != null
+            && setter.getNumberOfParameters() == 1)
     {
-        throw new UnsupportedOperationException("Setter not calculated in working copy.  Call toValueObject().getSetter()"); //$NON-NLS-1$
+      setters.add(setter);
     }
-    
-	/**
-	 * @return the "is" getter method or null if not found
-	 */
-	public IMethod getIsGetter() {
-		return _isGetter;
-	}
-	
-	private String getResolvedSignature(final IType type, final String unresolved)
-	{
-		String resolved = _resolvedSignatureMap.get(unresolved);
-		
-		if (resolved == null)
-		{
-			resolved = TypeUtil.resolveTypeSignature(_type, unresolved);
-			_resolvedSignatureMap.put(unresolved, resolved);
-		}
-		return resolved;
-	}
+  }
+
+  /**
+   * @return the bean properties spawned from this working copy Normally, there
+   *         is only one property in the array, however, since this working copy
+   *         represents all properties with the same name, there could be
+   *         multiple properties since setters can be overloaded by name and
+   *         could result in zero or one readable properties plus zero or more
+   *         write-only properties with the same name. I can't see anywhere in
+   *         the spec that covers this boundary case
+   */
+  public JDTBeanProperty toValueObject()
+  {
+    IMethod choosenGetter = isGetter != null ? isGetter : getter;
+    IMethod choosenSetter = chooseSetter(choosenGetter);
+    String unresolvedTypeSig = getUnresolvedType(choosenGetter, choosenSetter);
+    if (unresolvedTypeSig == null)
+    {
+      return new JDTBeanProperty(propertyName, null, null, Collections.EMPTY_LIST, choosenGetter, choosenSetter);
+    }
+    String resolvedTypeSig = typeResolver.resolveEraseTypeParams(unresolvedTypeSig);
+    IType resolvedType = resolveType(resolvedTypeSig);
+    List<String> parameterizedTypeSignatures = getParameterizedTypeSignature(unresolvedTypeSig);
+    return new JDTBeanProperty(
+            propertyName,
+            resolvedType,
+            resolvedTypeSig,
+            parameterizedTypeSignatures,
+            choosenGetter,
+            choosenSetter);
+  }
+
+  private IMethod chooseSetter(IMethod choosenGetter)
+  {
+    if (choosenGetter != null)
+    {
+      return determineMatchedSetter(choosenGetter);
+    }
+    else if (! setters.isEmpty())
+    {
+      return setters.get(0);
+    }
+    return null;
+  }
+
+  private IMethod determineMatchedSetter(IMethod choosenGetter)
+  {
+    if (setters.isEmpty())
+    {
+      return null;
+    }
+  
+    final String getterSig = typeResolver.resolveEraseTypeParams(getUnresolvedType(choosenGetter, null));
+    if (getterSig == null)
+    {
+      return null;
+    }
+    for (final Iterator it = setters.iterator(); it.hasNext();)
+    {
+      final IMethod setter = (IMethod) it.next();
+      assert (setter.getNumberOfParameters() == 1);
+      final String paramSig = typeResolver.resolveEraseTypeParams(setter.getParameterTypes()[0]);
+
+      if (paramSig.equals(getterSig))
+      {
+        return setter;
+      }
+    }
+    return null;
+  }
+
+  private static String getUnresolvedType(IMethod choosenGetter, IMethod choosenSetter)
+  {
+    try
+    {
+      if (choosenGetter != null)
+      {
+        return choosenGetter.getReturnType();
+      }
+      return choosenSetter.getParameterTypes()[0];
+    }
+    catch (JavaModelException jme)
+    {
+      JSFCommonPlugin.log(jme, "Error resolving bean property type signature"); //$NON-NLS-1$
+      return null;
+    }
+  }
+
+  private IType resolveType(String resolvedTypeSig)
+  {
+    final String typeSig = Signature.getElementType(resolvedTypeSig);
+    return TypeUtil.resolveType(type, typeSig);
+  }
+
+  private List<String> getParameterizedTypeSignature(String unresolvedTypeSignature)
+  {
+    List<String> typeSig = new ArrayList<String>();
+    for (String typeArg : Signature.getTypeArguments(unresolvedTypeSignature))
+    {
+      typeSig.add(typeResolver.resolveKeepTypeParams(typeArg));
+    }
+    return typeSig;
+  }
 }
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTTypeResolver.java b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTTypeResolver.java
new file mode 100644
index 0000000..5f7e69b
--- /dev/null
+++ b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/JDTTypeResolver.java
@@ -0,0 +1,315 @@
+/*******************************************************************************
+ * Copyright (c) 2020, 2021 Axon Ivy.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *    Reto Weiss/Axon Ivy      Cache resolved types
+ *    
+ ********************************************************************************/
+package org.eclipse.jst.jsf.common.util;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.ITypeParameter;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
+
+/**
+ * Resolves types of a type and caches them
+ * @author rwei
+ * @since 27.11.2020
+ */
+public class JDTTypeResolver
+{
+  private final Map<String, IType> resolvedTypes = new HashMap<String, IType>();
+  private final IType type;
+  private final IType[] superTypes;
+
+  /**
+   * Constructor
+   * @param type
+   * @param superTypes
+   */
+  public JDTTypeResolver(IType type, IType[] superTypes)
+  {
+    this.type = type;
+    this.superTypes = superTypes;
+  }
+
+  /**
+   * @param unresolvedSignature
+   * @return resolved method signatures with erased type parameters
+   */
+  public String resolveMethodEraseTypeParams(String unresolvedSignature)
+  {
+    return resolveMethod(unresolvedSignature, TypeParameters.ERASE);
+  }
+
+  /**
+   * @param unresolvedSignature
+   * @return resolve method signature with type parameters
+   */
+  public String resolveMethodKeepTypeParams(String unresolvedSignature)
+  {
+    return resolveMethod(unresolvedSignature, TypeParameters.KEEP);
+  }
+
+  private String resolveMethod(String unresolvedSignature, TypeParameters eraseTypeParameters)
+  {
+    final String unresolvedSignatureNormalized = unresolvedSignature.replaceAll("/", "."); //$NON-NLS-1$ //$NON-NLS-2$
+
+    // get the list of parameters
+    final String[] parameters = Signature.getParameterTypes(unresolvedSignatureNormalized);
+
+    for (int i = 0; i < parameters.length; i++)
+    {
+      // try to full resolve the type
+      parameters[i] = resolve(parameters[i], eraseTypeParameters);
+    }
+
+    // resolve return type
+    final String resolvedReturn = resolve(Signature.getReturnType(unresolvedSignatureNormalized),
+            eraseTypeParameters);
+    return Signature.createMethodSignature(parameters, resolvedReturn);
+  }
+
+  /**
+   * @param unresolvedSignature
+   * @return resolved signature with erased type params
+   */
+  public String resolveEraseTypeParams(String unresolvedSignature)
+  {
+    return resolve(unresolvedSignature, TypeParameters.ERASE);
+  }
+
+  /**
+   * @param unresolvedSignature
+   * @return resolved signature with type params
+   */
+  public String resolveKeepTypeParams(String unresolvedSignature)
+  {
+    return resolve(unresolvedSignature, TypeParameters.KEEP);
+  }
+
+  private String resolve(String unresolvedSignature, TypeParameters eraseTypeParameters)
+  {
+    final int sigKind = Signature.getTypeSignatureKind(unresolvedSignature);
+
+    switch (sigKind)
+    {
+      case Signature.BASE_TYPE_SIGNATURE:
+        return unresolvedSignature;
+
+      case Signature.ARRAY_TYPE_SIGNATURE:
+      {
+        final String elementType = Signature.getElementType(unresolvedSignature);
+
+        if (Signature.getTypeSignatureKind(elementType) == Signature.BASE_TYPE_SIGNATURE)
+        {
+          return unresolvedSignature;
+        }
+
+        final String resolvedElementType = resolveRelative(elementType, eraseTypeParameters);
+        String resultType = ""; //$NON-NLS-1$
+        for (int i = 0; i < Signature.getArrayCount(unresolvedSignature); i++)
+        {
+          resultType += Signature.C_ARRAY;
+        }
+
+        return resultType + resolvedElementType;
+      }
+
+      case Signature.TYPE_VARIABLE_SIGNATURE:
+        return resolveRelative(unresolvedSignature, eraseTypeParameters);
+
+      case Signature.CLASS_TYPE_SIGNATURE:
+        return resolveRelative(unresolvedSignature, eraseTypeParameters);
+
+      case Signature.WILDCARD_TYPE_SIGNATURE:
+        // strip the wildcard and try again. Too bad Signature doesn't seem to
+        // have a method
+        // for this
+        if (unresolvedSignature.charAt(0) == Signature.C_STAR)
+        {
+          return TypeConstants.TYPE_JAVAOBJECT;
+        }
+        return resolve(unresolvedSignature.substring(1), eraseTypeParameters);
+
+      case Signature.CAPTURE_TYPE_SIGNATURE:
+        // strip the capture and try again
+        return resolve(Signature.removeCapture(unresolvedSignature), eraseTypeParameters);
+      // case Signature.TYPE_VARIABLE_SIGNATURE:
+      // resolveSignatureRelative(owningType, typeSignature,
+      // eraseTypeParameters);
+
+      default:
+        return unresolvedSignature;
+    }
+  }
+
+  /**
+   * @param owningType -- type relative to which typeSignature will be resolved
+   * @param typeSignature -- non-array type signature
+   * @return the resolved type signature if possible or typeSignature if not
+   */
+  private String resolveRelative(final String typeSignature, final TypeParameters eraseTypeParameters)
+  {
+    // if already fully resolved, return the input
+    if (typeSignature.charAt(0) == Signature.C_RESOLVED)
+    {
+      return typeSignature;
+    }
+
+    List<String> typeParameters = new ArrayList<String>();
+
+    IType resolvedType = resolveType(typeSignature);
+
+    if (resolvedType != null)
+    {
+      if (eraseTypeParameters == TypeParameters.KEEP)
+      {
+        // ensure that type parameters are resolved recursively
+        for (String typeParam : Signature.getTypeArguments(typeSignature))
+        {
+          typeParam = Signature.removeCapture(typeParam);
+          // check and remove bound wildcarding (extends/super/?)
+          if (Signature.getTypeSignatureKind(typeParam) == Signature.WILDCARD_TYPE_SIGNATURE)
+          {
+            // convert ? to Object, strip extends/super
+            if (typeParam.charAt(0) == Signature.C_STAR)
+            {
+              typeParam = TypeConstants.TYPE_JAVAOBJECT;
+            }
+            else
+            {
+              typeParam = typeParam.substring(1);
+            }
+          }
+          final String resolvedParameter = resolveRelative(
+                  // use the enclosing type,
+                  // *not* the resolved type because
+                  // we need to resolve in that context
+                  typeParam, eraseTypeParameters);
+          typeParameters.add(resolvedParameter);
+        }
+      }
+
+      final String resolvedTypeSignature = Signature.createTypeSignature(resolvedType.getFullyQualifiedName(),
+              true);
+
+      if (typeParameters.size() > 0 && eraseTypeParameters == TypeParameters.KEEP)
+      {
+        StringBuffer sb = new StringBuffer(resolvedTypeSignature);
+
+        if (sb.charAt(sb.length() - 1) == ';')
+        {
+          sb = sb.delete(sb.length() - 1, sb.length());
+        }
+
+        sb.append("<"); //$NON-NLS-1$
+        for (String param : typeParameters)
+        {
+          // System.out.println("type param:
+          // "+resolvedType.getTypeParameter(param));
+          sb.append(param);
+        }
+
+        // replace the dangling ',' with the closing ">"
+        sb.append(">;"); //$NON-NLS-1$
+        return sb.toString();
+      }
+
+      return resolvedTypeSignature;
+    }
+
+    if (Signature.getTypeSignatureKind(typeSignature) == Signature.CLASS_TYPE_SIGNATURE
+            || Signature.getTypeSignatureKind(typeSignature) == Signature.TYPE_VARIABLE_SIGNATURE)
+    {
+      // if we are unable to resolve, check to see if the owning type has
+      // a parameter by this name
+      ITypeParameter typeParam = type.getTypeParameter(Signature.getSignatureSimpleName(typeSignature));
+
+      // if we have a type parameter and it hasn't been resolved to a type,
+      // then assume it is a method template placeholder (i.e. T in ArrayList).
+      // at runtime these unresolved parameter variables are effectively
+      // turned into Object's. For example, think List.add(E o). At runtime,
+      // E will behave exactly like java.lang.Object in that signature
+      if (typeParam.exists())
+      {
+        return TypeConstants.TYPE_JAVAOBJECT;
+      }
+
+      // TODO: is there a better way to handle a failure to resolve
+      // than just garbage out?
+      // JSFCommonPlugin.log(new Exception("Failed to resolve type:
+      // "+typeSignature), "Failed to resolve type: "+typeSignature);
+      // //$NON-NLS-1$ //$NON-NLS-2$
+    }
+
+    return typeSignature;
+  }
+
+  private IType resolveType(final String typeSignature)
+  {
+    final String typeName = TypeUtil.getFullyQualifiedName(typeSignature);
+    return resolveTypeName(typeName);
+  }
+  
+  IType resolveTypeName(String typeName)
+  {
+    IType resolved = resolvedTypes.get(typeName);
+    if (resolved != null)
+    {
+      return resolved;
+    }
+    resolved = resolveTypeNameRelative(typeName);
+    resolvedTypes.put(typeName, resolved);
+    return resolved;
+  }
+
+  private IType resolveTypeNameRelative(String typeName)
+  {
+    try
+    {
+      String[][] resolved = type.resolveType(typeName);
+      if (resolved != null && resolved.length > 0)
+      {
+        return type.getJavaProject().findType(resolved[0][0], resolved[0][1]);
+      }
+      return resolveInParents(typeName);
+    }
+    catch (JavaModelException jme)
+    {
+      return null;
+    }
+  }
+
+  private IType resolveInParents(String fullyQualifiedName)
+          throws JavaModelException
+  {
+    for (IType superType : superTypes)
+    {
+      String[][] resolved = superType.resolveType(fullyQualifiedName);
+      if (resolved != null && resolved.length > 0)
+      {
+        return type.getJavaProject().findType(resolved[0][0], resolved[0][1]);
+      }
+    }
+    return null;
+  }
+
+  private enum TypeParameters
+  {
+    ERASE, KEEP
+  }
+}
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/TypeUtil.java b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/TypeUtil.java
index 134d95b..067d520 100644
--- a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/TypeUtil.java
+++ b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/common/util/TypeUtil.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2006, 2010 Oracle Corporation.
+ * Copyright (c) 2006, 2021 Oracle Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -9,12 +9,12 @@
  *
  * Contributors:
  *    Cameron Bateman/Oracle - initial API and implementation
+ *    Reto Weiss/Axon Ivy    - Cache resolved types
  *    
  ********************************************************************************/
 
 package org.eclipse.jst.jsf.common.util;
 
-import java.util.ArrayList;
 import java.util.List;
 
 import org.eclipse.jdt.core.IField;
@@ -45,236 +45,20 @@
         		|| (Signature.getTypeSignatureKind(typeSignature) == Signature.ARRAY_TYPE_SIGNATURE
         			&& Signature.getElementType(typeSignature).charAt(0) == Signature.C_RESOLVED))
         {
-            IType type = null;
-            
             try
             {
-                type = owningType.getJavaProject().
+                return owningType.getJavaProject().
                            findType(getFullyQualifiedName(typeSignature));
             }
             catch (JavaModelException jme)
             {
                 // do nothing; return type == null;
             }
-            
-            return type;
+            return null;
         }
-        
-        
         return resolveTypeRelative(owningType, typeSignature);
     }
 
-    /**
-     * Fully equivalent to:
-     * 
-     * #resolveTypeSignature(owningType, typeSignature, true)
-     * 
-     * If resolved, type signature has generic type parameters erased (absent).
-     * 
-     * @param owningType
-     * @param typeSignature
-     * @return the resolved type signature for typeSignature in owningType or
-     * typeSignature unchanged if cannot resolve.
-     */
-    public static String resolveTypeSignature(final IType owningType, final String typeSignature)
-    {
-        return resolveTypeSignature(owningType, typeSignature, true);
-    }
-    
-    /**
-     * Resolve typeSignature in the context of owningType.  This method will return 
-     * a type erased signture if eraseTypeParameters == true and will attempt to
-     * resolve and include parameters if eraseTypeParamters == false
-     * 
-     * NOTE: special rules apply to the way unresolved type parameters and wildcards
-     * are resolved:
-     * 
-     * 1) If a fully unresolved type parameter is found, then it will be replaced with Ljava.lang.Object;
-     * 
-     * i.e.  List<T>  -> Ljava.util.List<Ljava.lang.Object;>;  for any unresolved T.
-     * 
-     * 2) Any bounded wildcard will be replaced by the bound:
-     * 
-     * i.e. List<? extends String> -> Ljava.util.List<Ljava.lang.String;>;
-     * i.e. List<? super String> -> Ljava.util.List<Ljava.lang.String;>;
-     * 
-     * Note limitation here: bounds that use 'super' will take the "best case" scenario that the list
-     * type is of that type.
-     * 
-     * 3) The unbounded wildcard will be replaced by Ljava.lang.Object;
-     * 
-     * i.e. List<?> -> Ljava.util.List<Ljava.lang.Object;>;
-     * 
-     * 
-     * The reason for this substition is to return the most accurate reasonable approximation
-     * of the type within what is known by owningType
-     * 
-     * @param owningType
-     * @param typeSignature
-     * @param eraseTypeParameters if set to false, type parameters are resolved included
-     * in the signature
-     * @return the resolved type signature for typeSignature in owningType or
-     * typeSignature unchanged if cannot resolve.
-     */
-    public static String resolveTypeSignature(final IType owningType, final String typeSignature, boolean eraseTypeParameters)
-    {
-        final int sigKind = Signature.getTypeSignatureKind(typeSignature);
-    
-        switch (sigKind)
-        {
-            case Signature.BASE_TYPE_SIGNATURE:
-                return typeSignature;
-                
-            case Signature.ARRAY_TYPE_SIGNATURE:
-            {
-                final String elementType = Signature.getElementType(typeSignature);
-                
-                if (Signature.getTypeSignatureKind(elementType) == Signature.BASE_TYPE_SIGNATURE)
-                {
-                    return typeSignature;
-                }
-
-                final String resolvedElementType = resolveSignatureRelative(owningType, elementType, eraseTypeParameters);
-                String resultType = ""; //$NON-NLS-1$
-                for (int i = 0; i < Signature.getArrayCount(typeSignature);i++)
-                {
-                    resultType+=Signature.C_ARRAY;
-                }
-                
-                return resultType+resolvedElementType;
-            }
-
-            case Signature.TYPE_VARIABLE_SIGNATURE:
-            	return resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);
-            
-            case Signature.CLASS_TYPE_SIGNATURE:
-                return resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);
-
-            case Signature.WILDCARD_TYPE_SIGNATURE:
-                // strip the wildcard and try again.  Too bad Signature doesn't seem to have a method
-                // for this
-                if (typeSignature.charAt(0) == Signature.C_STAR)
-                {
-                    return TypeConstants.TYPE_JAVAOBJECT;
-                }
-                return resolveTypeSignature(owningType, typeSignature.substring(1), eraseTypeParameters);
-            
-            case Signature.CAPTURE_TYPE_SIGNATURE:
-                // strip the capture and try again
-                return resolveTypeSignature(owningType, Signature.removeCapture(typeSignature), eraseTypeParameters);
-//            case Signature.TYPE_VARIABLE_SIGNATURE:
-//                resolveSignatureRelative(owningType, typeSignature, eraseTypeParameters);
-
-            default:
-                return typeSignature;
-        }
-    }
-    
-    /**
-     * @param owningType -- type relative to which typeSignature will be resolved
-     * @param typeSignature -- non-array type signature
-     * @return the resolved type signature if possible or typeSignature if not
-     */
-    private static String resolveSignatureRelative(final IType owningType, final String typeSignature, final boolean eraseTypeParameters)
-    {
-        // if already fully resolved, return the input
-        if (typeSignature.charAt(0) == Signature.C_RESOLVED)
-        {
-            return typeSignature;
-        }
-
-        List<String> typeParameters = new ArrayList<String>();
-
-        IType resolvedType = resolveTypeRelative(owningType, typeSignature);
-
-        if (resolvedType != null)
-        {
-            if (!eraseTypeParameters)
-            {
-                // ensure that type parameters are resolved recursively
-                for (String typeParam : Signature.getTypeArguments(typeSignature))
-                {
-                    typeParam = Signature.removeCapture(typeParam);
-                    // check and remove bound wildcarding (extends/super/?)
-                    if (Signature.getTypeSignatureKind(typeParam) == Signature.WILDCARD_TYPE_SIGNATURE)
-                    {
-                        // convert ? to Object, strip extends/super
-                        if (typeParam.charAt(0) == Signature.C_STAR)
-                        {
-                            typeParam = TypeConstants.TYPE_JAVAOBJECT;
-                        }
-                        else
-                        {
-                            typeParam = typeParam.substring(1);
-                        }
-                    }
-                    final String resolvedParameter = 
-                    	resolveSignatureRelative(
-                    			// use the enclosing type, 
-                    			// *not* the resolved type because 
-                    			// we need to resolve in that context
-                    			owningType, 
-                    				typeParam, eraseTypeParameters);
-                    typeParameters.add(resolvedParameter);
-                }
-            }
-
-            final String  resolvedTypeSignature = 
-                Signature.createTypeSignature
-                    (resolvedType.getFullyQualifiedName(), true);
-           
-
-            if (typeParameters.size() > 0 && !eraseTypeParameters)
-            {
-                StringBuffer sb = new StringBuffer(resolvedTypeSignature);
-
-                if (sb.charAt(sb.length()-1) == ';')
-                {
-                    sb = sb.delete(sb.length()-1, sb.length());
-                }
-                
-                sb.append("<"); //$NON-NLS-1$
-                for(String param : typeParameters)
-                {
-                    //System.out.println("type param: "+resolvedType.getTypeParameter(param));
-                    sb.append(param);
-                }
-                
-                // replace the dangling ',' with the closing ">"
-                sb.append(">;"); //$NON-NLS-1$
-                return sb.toString();
-            }
-            
-            return resolvedTypeSignature;
-        }
-
-        if (Signature.getTypeSignatureKind(typeSignature) == 
-                Signature.CLASS_TYPE_SIGNATURE
-            || Signature.getTypeSignatureKind(typeSignature)
-                == Signature.TYPE_VARIABLE_SIGNATURE)
-        {
-            // if we are unable to resolve, check to see if the owning type has
-            // a parameter by this name
-            ITypeParameter typeParam = owningType.getTypeParameter(Signature.getSignatureSimpleName(typeSignature));
-            
-            // if we have a type parameter and it hasn't been resolved to a type,
-            // then assume it is a method template placeholder (i.e. T in ArrayList).
-            // at runtime these unresolved parameter variables are effectively 
-            // turned into Object's.  For example, think List.add(E o).  At runtime,
-            // E will behave exactly like java.lang.Object in that signature
-            if (typeParam.exists())
-            {
-                return TypeConstants.TYPE_JAVAOBJECT;
-            }
-            
-            // TODO: is there a better way to handle a failure to resolve
-            // than just garbage out?
-            //JSFCommonPlugin.log(new Exception("Failed to resolve type: "+typeSignature), "Failed to resolve type: "+typeSignature); //$NON-NLS-1$ //$NON-NLS-2$
-        }
-        
-        return typeSignature;
-    }
-
     private static IType resolveTypeRelative(final IType owningType, final String typeSignature)
     {
         final String fullName = getFullyQualifiedName(typeSignature);
@@ -313,37 +97,6 @@
         return Signature.createTypeSignature(fullyQualifiedName, true);
     }
 
-    
-    /**
-     * @param owner
-     * @param unresolvedSignature
-     * @return the resolved method signature for unresolvedSignature in owner
-     */
-    public static String resolveMethodSignature(final IType  owner, 
-                                         final String unresolvedSignature)
-    {
-        
-        final String unresolvedSignatureNormalized =
-            unresolvedSignature.replaceAll("/", "."); //$NON-NLS-1$ //$NON-NLS-2$
-        
-        // get the list of parameters
-        final String[] parameters = 
-            Signature.getParameterTypes(unresolvedSignatureNormalized);
-        
-        for (int i = 0; i < parameters.length; i++)
-        {
-            // try to full resolve the type
-            parameters[i] = resolveTypeSignature(owner, parameters[i]);
-        }
-        
-        // resolve return type
-        final String resolvedReturn = 
-            resolveTypeSignature(owner, 
-                                  Signature.getReturnType(unresolvedSignatureNormalized));
-        
-        return Signature.createMethodSignature(parameters, resolvedReturn);
-    }
-    
     /**
      * @param typeSignature     
      * @return a fully qualified Java class name from a type signature
@@ -355,7 +108,7 @@
         final String typeName = Signature.getSignatureSimpleName(typeSignature);
         return "".equals(packageName) ? typeName : packageName + "." + typeName;  //$NON-NLS-1$//$NON-NLS-2$
     }
-    
+
     private static IType resolveInParents(IType  childType, String fullyQualifiedName)
                                 throws JavaModelException
     {
@@ -407,7 +160,7 @@
             return null;
         }
     }
-    
+
     /**
      * @param type
      * @param typeParamSignature -- must be a Type Variable Signature
@@ -452,7 +205,7 @@
         
         return null;
     }
-    
+
     /**
      * @param type
      * @param fieldName
@@ -493,7 +246,7 @@
         
         return false;
     }
-    
+
     /**
      * @param typeSig1 the type signature of the first enum. Must be non-null, fully resolved enum type.
      * @param typeSig2 the type signature of the second enum.  Must be non-null, fully resolved enum type.
@@ -525,7 +278,7 @@
         // only comparable if is the same class
         return typeSig1.equals(typeSig2);
     }
-    
+
     /**
      * @param typeSig1 the type signature of the first enum. Must be non-null, fully resolved enum type.
      * @param typeSig2 the type signature of the second enum. Must be non-null, fully resolved enum type.
@@ -556,7 +309,6 @@
         // can never be equal
         return !typeSig1.equals(typeSig2);
     }
-    
 
     /**
      * NOTE: we diverge from IType.isEnum() because we also return true if the base type
@@ -591,7 +343,7 @@
         // if unresolved assume false
         return false;
     }
-    
+
     private TypeUtil()
     {
         // no external instantiation
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/IBoundedListTypeDescriptorImpl.java b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/IBoundedListTypeDescriptorImpl.java
index e7b7a00..7061268 100644
--- a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/IBoundedListTypeDescriptorImpl.java
+++ b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/IBoundedListTypeDescriptorImpl.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2006, 2019 IBM Corporation and others.
+ * Copyright (c) 2006, 2021 IBM Corporation and others.
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -8,7 +8,8 @@
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
- *     IBM Corporation - initial API and implementation
+ *     IBM Corporation     - initial API and implementation
+ *     Reto Weiss/Axon Ivy - Cache JDTBeanIntrospector
  *******************************************************************************/
 /**
  * <copyright>
@@ -24,14 +25,11 @@
 
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.EClass;
-import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.Signature;
-import org.eclipse.jst.jsf.common.JSFCommonPlugin;
 import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
 import org.eclipse.jst.jsf.common.util.JDTBeanIntrospector;
-import org.eclipse.jst.jsf.common.util.TypeUtil;
+import org.eclipse.jst.jsf.common.util.JDTBeanMethod;
 import org.eclipse.jst.jsf.context.symbol.IBoundedListTypeDescriptor;
 import org.eclipse.jst.jsf.context.symbol.IJavaTypeDescriptor2;
 import org.eclipse.jst.jsf.context.symbol.IPropertySymbol;
@@ -73,6 +71,7 @@
      * <!-- end-user-doc -->
      * @generated
      */
+    @Override
     protected EClass eStaticClass() {
         return SymbolPackage.Literals.IBOUNDED_LIST_TYPE_DESCRIPTOR;
     }
@@ -137,68 +136,55 @@
         
         if (type != null)
         {
-            final JDTBeanIntrospector introspector = 
-                new JDTBeanIntrospector(type);
+            final JDTBeanIntrospector introspector = JDTBeanIntrospector.forType(type);
             
-            final IMethod callMethod = 
-                matchMethod(methodName, methodArguments, introspector.getAllMethods());
+            final JDTBeanMethod callMethod = 
+                matchMethod(methodName, methodArguments, introspector.getMethods());
             
             if (callMethod != null)
             {
-                try 
-                {
-                    // resolve the method's return type; don't erase parameters
-                    final String retTypeSignature = 
-                        TypeUtil.resolveTypeSignature
-                            (type, callMethod.getReturnType(), false) ;
-                    
-                    final IPropertySymbol  propSymbol = 
-                        SymbolFactory.eINSTANCE.createIPropertySymbol();
+                // resolve the method's return type; don't erase parameters
+                final String retTypeSignature = callMethod.getResolvedReturnTypeUnerased();
+                final IPropertySymbol  propSymbol = 
+                    SymbolFactory.eINSTANCE.createIPropertySymbol();
 
-                    // TODO: there is a possible problem here for non-string keyed maps
-                    propSymbol.setName(symbolName);
-                    propSymbol.setReadable(true);
-                    IJavaTypeDescriptor2 typeDesc = 
-                        SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();
-                    
-                    typeDesc.setArrayCount(Signature.getArrayCount(retTypeSignature));
-                    
-                    // may be null
-                    typeDesc.setType(resolveType(retTypeSignature));
-                    typeDesc.setTypeSignatureDelegate(retTypeSignature);
-                    propSymbol.setTypeDescriptor(typeDesc);
-                    result = propSymbol;
-                } 
-                catch (JavaModelException e) 
-                {
-                    JSFCommonPlugin.log(e);
-                    // fall-through and return null result
-                }
+                // TODO: there is a possible problem here for non-string keyed maps
+                propSymbol.setName(symbolName);
+                propSymbol.setReadable(true);
+                IJavaTypeDescriptor2 typeDesc = 
+                    SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();
+                
+                typeDesc.setArrayCount(Signature.getArrayCount(retTypeSignature));
+                
+                // may be null
+                typeDesc.setType(resolveType(retTypeSignature));
+                typeDesc.setTypeSignatureDelegate(retTypeSignature);
+                propSymbol.setTypeDescriptor(typeDesc);
+                result = propSymbol;
             }
         }
         
         return result;
     }
     
-    private IMethod matchMethod(String name, List methodArguments, IMethod[] allMethods)
+    private JDTBeanMethod matchMethod(String name, List methodArguments, JDTBeanMethod[] allMethods)
     {
         final List argSigs = convertArgsToSignatures(methodArguments);
-        IMethod matchedMethod = null;
         
         for (int i = 0; i < allMethods.length; i++)
         {
-            final IMethod method = allMethods[i];
+            final JDTBeanMethod method = allMethods[i];
             
             // check for names and argument count match
-            if (method.getParameterTypes().length == argSigs.size()
+            if (method.getUnresolvedParameterTypesUnerased().length == argSigs.size()
                     && method.getElementName().equals(name))
             {
-                String[] methods = method.getParameterTypes();
+                String[] paramSigs = method.getUnresolvedParameterTypesUnerased(); // RWEI seems not be correct to get unresolved types here
                 // need to verify argument matches
                 boolean isMatched = true;
-                CHECK_ARGUMENTS: for (int j = 0; j < methods.length; j++)
+                CHECK_ARGUMENTS: for (int j = 0; j < paramSigs.length; j++)
                 {
-                    if (!methods[j].equals(argSigs.get(j)))
+                    if (!paramSigs[j].equals(argSigs.get(j)))
                     {
                         // not a match
                         isMatched = false;
@@ -213,7 +199,7 @@
             }
         }
 
-        return matchedMethod;
+        return null;
     }
 
     private List convertArgsToSignatures(List methodArgs)
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/IJavaTypeDescriptor2Impl.java b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/IJavaTypeDescriptor2Impl.java
index 95fbaa8..d1588ef 100644
--- a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/IJavaTypeDescriptor2Impl.java
+++ b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/IJavaTypeDescriptor2Impl.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2006, 2010 Oracle Corporation.
+ * Copyright (c) 2006, 2021 Oracle Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -9,6 +9,7 @@
  *
  * Contributors:
  *    Cameron Bateman/Oracle - initial API and implementation
+ *    Reto Weiss/Axon Ivy    - Cache JDTBeanIntrospector
  *    
  ********************************************************************************/
 package org.eclipse.jst.jsf.context.symbol.internal.impl;
@@ -28,13 +29,13 @@
 import org.eclipse.jdt.core.Flags;
 import org.eclipse.jdt.core.IJavaElement;
 import org.eclipse.jdt.core.IJavaProject;
-import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.Signature;
 import org.eclipse.jst.jsf.common.JSFCommonPlugin;
 import org.eclipse.jst.jsf.common.internal.types.TypeInfoCache;
 import org.eclipse.jst.jsf.common.util.JDTBeanIntrospector;
+import org.eclipse.jst.jsf.common.util.JDTBeanMethod;
 import org.eclipse.jst.jsf.common.util.JDTBeanProperty;
 import org.eclipse.jst.jsf.common.util.TypeUtil;
 import org.eclipse.jst.jsf.context.symbol.IBeanMethodSymbol;
@@ -70,27 +71,27 @@
      * @generated
      */
     @SuppressWarnings("hiding")
-	public static final String copyright = "Copyright 2006 Oracle";  //$NON-NLS-1$
+    public static final String copyright = "Copyright 2006 Oracle";  //$NON-NLS-1$
 
     /**
      * The default value of the '{@link #getType() <em>Type</em>}' attribute.
      * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+     * <!-- end-user-doc -->
      * @see #getType()
      * @generated
      * @ordered
      */
-	protected static final IType TYPE_EDEFAULT = null;
+    protected static final IType TYPE_EDEFAULT = null;
 
     /**
      * The cached value of the '{@link #getType() <em>Type</em>}' attribute.
      * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+     * <!-- end-user-doc -->
      * @see #getType()
      * @generated
      * @ordered
      */
-	protected IType type = TYPE_EDEFAULT;
+    protected IType type = TYPE_EDEFAULT;
 
     /**
      * The default value of the '{@link #getArrayCount() <em>Array Count</em>}' attribute.
@@ -125,7 +126,7 @@
      * @ordered
      */
     @SuppressWarnings("hiding")
-	protected static final IJavaElement JDT_CONTEXT_EDEFAULT = null;
+    protected static final IJavaElement JDT_CONTEXT_EDEFAULT = null;
 
     /**
      * The cached value of the '{@link #getJdtContext() <em>Jdt Context</em>}' attribute.
@@ -136,24 +137,25 @@
      * @ordered
      */
     @SuppressWarnings("hiding")
-	protected IJavaElement jdtContext = JDT_CONTEXT_EDEFAULT;
+    protected IJavaElement jdtContext = JDT_CONTEXT_EDEFAULT;
 
     /**
      * <!-- begin-user-doc -->
-	 * <!-- end-user-doc -->
+     * <!-- end-user-doc -->
      * @generated
      */
-	protected IJavaTypeDescriptor2Impl() {
+    protected IJavaTypeDescriptor2Impl() {
         super();
     }
 
     /**
      * <!-- begin-user-doc -->
      * @return the static class 
-	 * <!-- end-user-doc -->
+     * <!-- end-user-doc -->
      * @generated
      */
-	protected EClass eStaticClass() {
+    @Override
+    protected EClass eStaticClass() {
         return SymbolPackage.Literals.IJAVA_TYPE_DESCRIPTOR2;
     }
 
@@ -161,31 +163,32 @@
      * <!-- begin-user-doc -->
      * @return the JDT type descriptor; if type is an array then this type
      * represent's the array base type only
-	 * <!-- end-user-doc -->
+     * <!-- end-user-doc -->
      * @generated
      */
-	public IType getType() {
+    public IType getType() {
         return type;
     }
 
     /**
      * <!-- begin-user-doc -->
      * @param newType 
-	 * <!-- end-user-doc -->
+     * <!-- end-user-doc -->
      * @generated
      */
-	public void setType(IType newType) {
+    public void setType(IType newType) {
         IType oldType = type;
         type = newType;
         if (eNotificationRequired())
             eNotify(new ENotificationImpl(this, Notification.SET, SymbolPackage.IJAVA_TYPE_DESCRIPTOR2__TYPE, oldType, type));
     }
 
-	/**
-	 * @see org.eclipse.jst.jsf.context.symbol.internal.impl.ITypeDescriptorImpl#getInterfaceTypeSignatures()
-	 * @generated NOT
-	 */
-	public EList getInterfaceTypeSignatures() 
+    /**
+     * @see org.eclipse.jst.jsf.context.symbol.internal.impl.ITypeDescriptorImpl#getInterfaceTypeSignatures()
+     * @generated NOT
+     */
+    @Override
+    public EList getInterfaceTypeSignatures() 
     {
         EList  interfaces = new BasicEList();
         
@@ -208,6 +211,7 @@
      * @see org.eclipse.jst.jsf.context.symbol.internal.impl.ITypeDescriptorImpl#getSuperTypeSignatures()
      * @generated NOT
      */
+    @Override
     public EList getSuperTypeSignatures() 
     {
         EList  interfaces = new BasicEList();
@@ -247,64 +251,66 @@
         }
     }
 
+    @Override
     public EList getProperties() 
     {
         return getBeanProperties();
     }
 
     
+    @Override
     public EList getMethods() 
     {
         return getBeanMethods();
     }
 
     /**
-	 * <!-- begin-user-doc -->
+     * <!-- begin-user-doc -->
      * @return the bean props for this java type 
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EList getBeanProperties() 
-	{
-	    TypeInfoCache typeInfoCache = TypeInfoCache.getInstance();
-	    IBeanPropertySymbol[] properties = typeInfoCache.getCachedPropertySymbols(type);
-	    Collection propertyColl;
-	    if (properties == null) {
-	        propertyColl = getPropertiesInternal();
-	        properties = (IBeanPropertySymbol[]) propertyColl.toArray(new IBeanPropertySymbol[propertyColl.size()]);
-	        typeInfoCache.cachePropertySymbols(type, properties);
-	    } 
-	    else 
-	    {
+     * <!-- end-user-doc -->
+     * @generated NOT
+     */
+    public EList getBeanProperties() 
+    {
+        TypeInfoCache typeInfoCache = TypeInfoCache.getInstance();
+        IBeanPropertySymbol[] properties = typeInfoCache.getCachedPropertySymbols(type);
+        Collection propertyColl;
+        if (properties == null) {
+            propertyColl = getPropertiesInternal();
+            properties = (IBeanPropertySymbol[]) propertyColl.toArray(new IBeanPropertySymbol[propertyColl.size()]);
+            typeInfoCache.cachePropertySymbols(type, properties);
+        } 
+        else 
+        {
             propertyColl = new ArrayList(properties.length);
             Collections.addAll(propertyColl, (Object[])properties);
-	    }
-	    BasicEList list = new BasicEList(propertyColl);
-	    return list;
-	}
+        }
+        BasicEList list = new BasicEList(propertyColl);
+        return list;
+    }
 
-	/**
-	 * <!-- begin-user-doc -->
+    /**
+     * <!-- begin-user-doc -->
      * @return the bean methods for this type  
-	 * <!-- end-user-doc -->
-	 * @generated NOT
-	 */
-	public EList getBeanMethods() {
-	    TypeInfoCache typeInfoCache = TypeInfoCache.getInstance();
-	    IBeanMethodSymbol[] methods = typeInfoCache.getCachedMethodSymbols(type);
-	    Collection methodColl;
-	    if (methods == null) 
-	    {
-	        methodColl = getMethodsInternal();
-	        methods = (IBeanMethodSymbol[]) methodColl.toArray(new IBeanMethodSymbol[methodColl.size()]);
-	        typeInfoCache.cacheMethodSymbols(type, methods);
-	    } else {
-	        methodColl = new ArrayList(methods.length);
-	        Collections.addAll(methodColl, (Object[])methods);
-	    }
-	    BasicEList list = new BasicEList(methodColl);
-		return list;
-	}
+     * <!-- end-user-doc -->
+     * @generated NOT
+     */
+    public EList getBeanMethods() {
+        TypeInfoCache typeInfoCache = TypeInfoCache.getInstance();
+        IBeanMethodSymbol[] methods = typeInfoCache.getCachedMethodSymbols(type);
+        Collection methodColl;
+        if (methods == null) 
+        {
+            methodColl = getMethodsInternal();
+            methods = (IBeanMethodSymbol[]) methodColl.toArray(new IBeanMethodSymbol[methodColl.size()]);
+            typeInfoCache.cacheMethodSymbols(type, methods);
+        } else {
+            methodColl = new ArrayList(methods.length);
+            Collections.addAll(methodColl, (Object[])methods);
+        }
+        BasicEList list = new BasicEList(methodColl);
+        return list;
+    }
 
     
     /**
@@ -328,11 +334,12 @@
             eNotify(new ENotificationImpl(this, Notification.SET, SymbolPackage.IJAVA_TYPE_DESCRIPTOR2__ARRAY_COUNT, oldArrayCount, arrayCount));
     }
 
-	/**
+    /**
      * <!-- begin-user-doc -->
      * <!-- end-user-doc -->
      * @generated
      */
+    @Override
     public IJavaElement getJdtContext() {
         return jdtContext;
     }
@@ -342,6 +349,7 @@
      * <!-- end-user-doc -->
      * @generated
      */
+    @Override
     public void setJdtContext(IJavaElement newJdtContext) {
         IJavaElement oldJdtContext = jdtContext;
         jdtContext = newJdtContext;
@@ -360,6 +368,7 @@
      * <!-- end-user-doc -->
      * @generated NOT
      */
+    @Override
     public IType resolveType(String resolvedTypeSignature) 
     {
         IType resolvedType = null;
@@ -401,6 +410,7 @@
      * <!-- end-user-doc -->
      * @generated
      */
+    @Override
     public Object eGet(int featureID, boolean resolve, boolean coreType) {
         switch (featureID) {
             case SymbolPackage.IJAVA_TYPE_DESCRIPTOR2__TYPE:
@@ -420,6 +430,7 @@
      * <!-- end-user-doc -->
      * @generated
      */
+    @Override
     public void eSet(int featureID, Object newValue) {
         switch (featureID) {
             case SymbolPackage.IJAVA_TYPE_DESCRIPTOR2__TYPE:
@@ -445,6 +456,7 @@
      * <!-- end-user-doc -->
      * @generated
      */
+    @Override
     public void eUnset(int featureID) {
         switch (featureID) {
             case SymbolPackage.IJAVA_TYPE_DESCRIPTOR2__TYPE:
@@ -468,6 +480,7 @@
      * <!-- end-user-doc -->
      * @generated
      */
+    @Override
     public boolean eIsSet(int featureID) {
         switch (featureID) {
             case SymbolPackage.IJAVA_TYPE_DESCRIPTOR2__TYPE:
@@ -482,71 +495,74 @@
         return super.eIsSet(featureID);
     }
 
+    @Override
     public boolean isArray() 
     {
-	    return getArrayCount() > 0;
+        return getArrayCount() > 0;
     }
 
     /**
-	 * @generated NOT
-	 */
-	public IObjectSymbol getArrayElement() 
-	{
-		if (isArray())
-		{
-			final String typeSignature = getTypeSignature();
-			final int arrayCount_ = Signature.getArrayCount(typeSignature);
-			final String baseType = Signature.getElementType(typeSignature);
-			final String elementTypeSignature = Signature.createArraySignature(baseType, arrayCount_-1);
+     * @generated NOT
+     */
+    @Override
+    public IObjectSymbol getArrayElement() 
+    {
+        if (isArray())
+        {
+            final String typeSignature = getTypeSignature();
+            final int arrayCount_ = Signature.getArrayCount(typeSignature);
+            final String baseType = Signature.getElementType(typeSignature);
+            final String elementTypeSignature = Signature.createArraySignature(baseType, arrayCount_-1);
 
-			final IJavaTypeDescriptor2 elementTypeDesc = 
-				SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();
-			final String fullyQualifiedElementType = TypeUtil.getFullyQualifiedName(baseType);
-			
-			IType elementType = null;
+            final IJavaTypeDescriptor2 elementTypeDesc = 
+                SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();
+            final String fullyQualifiedElementType = TypeUtil.getFullyQualifiedName(baseType);
+            
+            IType elementType = null;
 
-			try 
-			{
-			    IType myType = getType();
-				if (myType != null)
-				{
-					elementType = getType().getJavaProject()
-					                 .findType(fullyQualifiedElementType);
-				}
-			} 
-			catch (JavaModelException e) 
-			{
-				// suppress
-			}
+            try 
+            {
+                IType myType = getType();
+                if (myType != null)
+                {
+                    elementType = getType().getJavaProject()
+                                     .findType(fullyQualifiedElementType);
+                }
+            } 
+            catch (JavaModelException e) 
+            {
+                // suppress
+            }
 
-			if (elementType != null)
-			{
-				elementTypeDesc.setType(elementType);
-			}
-			else
-			{
-				elementTypeDesc.setTypeSignatureDelegate(elementTypeSignature);
-			}
+            if (elementType != null)
+            {
+                elementTypeDesc.setType(elementType);
+            }
+            else
+            {
+                elementTypeDesc.setTypeSignatureDelegate(elementTypeSignature);
+            }
             
             elementTypeDesc.setArrayCount(Signature.getArrayCount(elementTypeSignature));
-			
-			IPropertySymbol newPropertySymbol = 
-				SymbolFactory.eINSTANCE.createIPropertySymbol();
-			newPropertySymbol.setTypeDescriptor(elementTypeDesc);
-			newPropertySymbol.setWritable(true);
-			newPropertySymbol.setReadable(true);
-			newPropertySymbol.setName(fullyQualifiedElementType);
+            
+            IPropertySymbol newPropertySymbol = 
+                SymbolFactory.eINSTANCE.createIPropertySymbol();
+            newPropertySymbol.setTypeDescriptor(elementTypeDesc);
+            newPropertySymbol.setWritable(true);
+            newPropertySymbol.setReadable(true);
+            newPropertySymbol.setName(fullyQualifiedElementType);
             return newPropertySymbol;
-		}
+        }
 
-		return null;
-	}
+        return null;
+    }
 
-	/* (non-Javadoc)
-	 * @see org.eclipse.jst.jsf.context.symbol.internal.impl.ITypeDescriptorImpl#getTypeSignature()
+    /* (non-Javadoc)
+     * @see org.eclipse.jst.jsf.context.symbol.internal.impl.ITypeDescriptorImpl#getTypeSignature()
      * @generated NOT
-	 */
-	public String getTypeSignature() 
+     */
+    @Override
+    public String getTypeSignature() 
     {
         if (getType() == null)
         {
@@ -564,35 +580,34 @@
     }
 
     private Collection getPropertiesInternal()
-	{
+    {
         // if I'm an array then I have no bean properties
         if (isArray())
         {
             return Collections.EMPTY_LIST;
         }
         
-        final JDTBeanIntrospector  introspector = 
-            new JDTBeanIntrospector(getType());
+        final JDTBeanIntrospector  introspector = JDTBeanIntrospector.forType(type); 
         
-		final Map<String, JDTBeanProperty> properties = introspector.getProperties();
-		
-		final Collection calculatedProps = new ArrayList(properties.size());
+        final Map<String, JDTBeanProperty> properties = introspector.getProperties();
         
-		for (final Iterator<Map.Entry<String, JDTBeanProperty>> it = properties.entrySet().iterator(); it.hasNext();)
-		{
-		    Map.Entry<String, JDTBeanProperty> entry = it.next();
-		    final String propertyName = entry.getKey();
+        final Collection calculatedProps = new ArrayList(properties.size());
+        
+        for (final Iterator<Map.Entry<String, JDTBeanProperty>> it = properties.entrySet().iterator(); it.hasNext();)
+        {
+            Map.Entry<String, JDTBeanProperty> entry = it.next();
+            final String propertyName = entry.getKey();
             final JDTBeanProperty property = entry.getValue();
 
-			final IBeanPropertySymbol workingCopy =
-			    SymbolFactory.eINSTANCE.createIBeanPropertySymbol();
-			workingCopy.setName(propertyName);
-			workingCopy.setOwner(this);
+            final IBeanPropertySymbol workingCopy =
+                SymbolFactory.eINSTANCE.createIBeanPropertySymbol();
+            workingCopy.setName(propertyName);
+            workingCopy.setOwner(this);
                         
             final IJavaTypeDescriptor2 workingCopyDesc = 
                 SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();
             workingCopy.setTypeDescriptor(workingCopyDesc);
-			workingCopy.setReadable(property.isReadable());
+            workingCopy.setReadable(property.isReadable());
             workingCopy.setWritable(property.isWritable());
                             
             workingCopyDesc.setArrayCount(property.getArrayCount());
@@ -612,61 +627,58 @@
             }
             
             calculatedProps.add(workingCopy);
-		}
+        }
 
-		return calculatedProps;
-	}
+        return calculatedProps;
+    }
 
     private Collection getMethodsInternal()
-	{
-        JDTBeanIntrospector introspector =
-            new JDTBeanIntrospector(getType());
+    {
+        JDTBeanIntrospector introspector = JDTBeanIntrospector.forType(type);
         
-		IMethod[] methods = introspector.getAllMethods();
+        JDTBeanMethod[] methods = introspector.getMethods();
 
         List methodSymbols = new ArrayList();
 
-		for (int i = 0; i < methods.length; i++)
-		{
-			IMethod method = methods[i];
-			
-			try
-			{
-				// to be a bean method, it must not a constructor, must be public
-				// and must not be static
-				if (!method.isConstructor()
-						&& Flags.isPublic(method.getFlags())
-						&& !Flags.isStatic(method.getFlags()))
-				{
-					String methodName = method.getElementName();
-					IBeanMethodSymbol workingCopy = SymbolFactory.eINSTANCE.createIBeanMethodSymbol();
-					workingCopy.setName(methodName);
-					workingCopy.setOwner(this);
-                    workingCopy.setSignature(TypeUtil.
-                                                resolveMethodSignature
-                                                    (getType(), 
-                                                     method.getSignature()));
-					methodSymbols.add(workingCopy);
-				}
-			}
-			catch (JavaModelException jme)
-			{
-				// error reading meta-data.  Skip to next one
+        for (int i = 0; i < methods.length; i++)
+        {
+            JDTBeanMethod method = methods[i];
+            
+            try
+            {
+                // to be a bean method, it must not a constructor, must be public
+                // and must not be static
+                if (!method.isConstructor()
+                        && Flags.isPublic(method.getFlags())
+                        && !Flags.isStatic(method.getFlags()))
+                {
+                    String methodName = method.getElementName();
+                    IBeanMethodSymbol workingCopy = SymbolFactory.eINSTANCE.createIBeanMethodSymbol();
+                    workingCopy.setName(methodName);
+                    workingCopy.setOwner(this);
+                    workingCopy.setSignature(method.getResolvedSignatureErased());
+                    methodSymbols.add(workingCopy);
+                }
+            }
+            catch (JavaModelException jme)
+            {
+                // error reading meta-data.  Skip to next one
                 JSFCommonPlugin.log(jme);
-			}
-		}
-		
-		return methodSymbols;
-	}
+            }
+        }
+        
+        return methodSymbols;
+    }
 
 
     /**
      * <!-- begin-user-doc -->
      * @return the default string rep 
-	 * <!-- end-user-doc -->
+     * <!-- end-user-doc -->
      * @generated
      */
-	public String toString() {
+    @Override
+    public String toString() {
         if (eIsProxy()) return super.toString();
 
         StringBuffer result = new StringBuffer(super.toString());
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/JavaUtil.java b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/JavaUtil.java
index e7549c1..822438d 100644
--- a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/JavaUtil.java
+++ b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/JavaUtil.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
+ * Copyright (c) 2001, 2021 Oracle Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -8,7 +8,8 @@
  * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
- *     Oracle Corporation - initial API and implementation
+ *     Oracle Corporation  - initial API and implementation
+ *     Reto Weiss/Axon Ivy - Cache JDTBeanIntrospector
  *******************************************************************************/
 package org.eclipse.jst.jsf.context.symbol.internal.impl;
 
@@ -22,8 +23,8 @@
 import org.eclipse.jdt.ui.JavadocContentAccess;
 import org.eclipse.jst.jsf.common.JSFCommonPlugin;
 import org.eclipse.jst.jsf.common.util.JDTBeanIntrospector;
+import org.eclipse.jst.jsf.common.util.JDTBeanMethod;
 import org.eclipse.jst.jsf.common.util.JDTBeanProperty;
-import org.eclipse.jst.jsf.common.util.TypeUtil;
 import org.eclipse.jst.jsf.context.symbol.IBeanMethodSymbol;
 import org.eclipse.jst.jsf.context.symbol.IBeanPropertySymbol;
 
@@ -76,19 +77,13 @@
      */
     public static IMethod findCorrespondingMethod(final IBeanMethodSymbol symbol) {
         final IType type = symbol.getOwner().getType();
-        final JDTBeanIntrospector introspector = new JDTBeanIntrospector(type);
-        final IMethod[] methods = introspector.getAllMethods();
-        for (final IMethod method : methods) {
+        final JDTBeanIntrospector introspector = JDTBeanIntrospector.forType(type);
+        final JDTBeanMethod[] methods = introspector.getMethods();
+        for (final JDTBeanMethod method : methods) {
             if (method.getElementName().equals(symbol.getName())) {
-                try {
-                    final String currentMethodsSignature = TypeUtil.resolveMethodSignature(method.getDeclaringType(),
-                            method.getSignature());
-                    if (currentMethodsSignature.equals(symbol.getSignature())) {
-                        return method;
-                    }
-                } catch (final JavaModelException e) {
-                    JSFCommonPlugin.log(IStatus.WARNING, "error determining for method '" //$NON-NLS-1$
-                            + method.getElementName() + "'.", e); //$NON-NLS-1$
+                final String currentMethodsSignature = method.getResolvedSignatureErased();
+                if (currentMethodsSignature.equals(symbol.getSignature())) {
+                    return method.getMethod();
                 }
             }
         }
@@ -100,7 +95,7 @@
      * @return a JDTBeanProperty for the given property symbol
      */
     public static JDTBeanProperty findCorrespondingJDTProperty(final IBeanPropertySymbol propertySymbol) {
-        final JDTBeanIntrospector introspector = new JDTBeanIntrospector(propertySymbol.getOwner().getType());
+        final JDTBeanIntrospector introspector = JDTBeanIntrospector.forType(propertySymbol.getOwner().getType());
         return introspector.getProperties().get(propertySymbol.getName());
     }
 }
diff --git a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/Util.java b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/Util.java
index da955c8..7f57e7f 100644
--- a/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/Util.java
+++ b/jsf/plugins/org.eclipse.jst.jsf.common/src/org/eclipse/jst/jsf/context/symbol/internal/impl/Util.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007 Oracle Corporation.
+ * Copyright (c) 2007, 2021 Oracle Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -9,6 +9,7 @@
  *
  * Contributors:
  *    Cameron Bateman/Oracle - initial API and implementation
+ *    Reto Weiss/Axon Ivy    - Cache JDTBeanIntrospector
  *    
  ********************************************************************************/
 package org.eclipse.jst.jsf.context.symbol.internal.impl;
@@ -17,7 +18,6 @@
 import java.util.List;
 
 import org.eclipse.emf.common.util.EList;
-import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.Signature;
@@ -25,6 +25,7 @@
 import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
 import org.eclipse.jst.jsf.common.internal.types.ValueType;
 import org.eclipse.jst.jsf.common.util.JDTBeanIntrospector;
+import org.eclipse.jst.jsf.common.util.JDTBeanMethod;
 import org.eclipse.jst.jsf.common.util.TypeUtil;
 import org.eclipse.jst.jsf.context.symbol.IJavaTypeDescriptor2;
 import org.eclipse.jst.jsf.context.symbol.IPropertySymbol;
@@ -46,96 +47,90 @@
         // the call then do this the hard way...
         if (type != null && result == null)
         {
-            final JDTBeanIntrospector introspector = 
-                new JDTBeanIntrospector(type);
+            final JDTBeanIntrospector introspector = JDTBeanIntrospector.forType(type);
 
-            final IMethod callMethod = 
-                Util.matchMethod(methodName, methodArguments, introspector.getAllMethods(),typeDesc.getTypeParameterSignatures());
+            final JDTBeanMethod callMethod = 
+                Util.matchMethod(methodName, methodArguments, introspector.getMethods(),typeDesc.getTypeParameterSignatures());
 
             if (callMethod != null)
             {
-                try 
+                try
                 {
-                    // resolve the method's return type; don't erase parameters
-                    String retTypeSignature = callMethod.getReturnType();
-                        
-                    // if we have a type variable, try to parameter match it
-                    if (Signature.getTypeSignatureKind(retTypeSignature) == Signature.TYPE_VARIABLE_SIGNATURE)
-                    {
-                        retTypeSignature = TypeUtil.matchTypeParameterToArgument
-                            (type
-                               , retTypeSignature, typeDesc.getTypeParameterSignatures());
-                        
-                        if (retTypeSignature == null)
-                        {
-                            retTypeSignature = TypeConstants.TYPE_JAVAOBJECT;
-                        }
-                    }
-                    // otherwise, try and resolve it in type
-                    else
-                    {
-                    	retTypeSignature = TypeUtil.resolveTypeSignature
-                    		(type, callMethod.getReturnType(), false);
-                    }
-
-                    final IPropertySymbol  propSymbol = 
-                        SymbolFactory.eINSTANCE.createIPropertySymbol();
-
-                    // TODO: there is a possible problem here for non-string keyed maps
-                    propSymbol.setName(symbolName);
-                    propSymbol.setReadable(true);
-                    
-                    {
-                        IJavaTypeDescriptor2 newTypeDesc = null;
-                        
-                        if (retTypeSignature.equals(TypeConstants.TYPE_JAVAOBJECT))
-                        {
-                            newTypeDesc = SymbolFactory.eINSTANCE.createIBoundedJavaTypeDescriptor();
-                        }
-                        else
-                        {
-                            newTypeDesc = SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();
-                        }
-                        
-                        newTypeDesc.setArrayCount(Signature.getArrayCount(retTypeSignature));
-                        
-                        // may be null
-                        newTypeDesc.setType(typeDesc.resolveType(retTypeSignature));
-                        newTypeDesc.setTypeSignatureDelegate(retTypeSignature);
-                        propSymbol.setTypeDescriptor(newTypeDesc);
-                    }
-                    
-                    result = propSymbol;
-                } 
-                catch (JavaModelException e) 
-                {
-                    JSFCommonPlugin.log(e);
-                    // fall-through and return null result
-                }
+                  // resolve the method's return type; don't erase parameters
+                  String retTypeSignature = callMethod.getUnresolvedReturnTypeUnerased();
+                      
+                  // if we have a type variable, try to parameter match it
+                  if (Signature.getTypeSignatureKind(retTypeSignature) == Signature.TYPE_VARIABLE_SIGNATURE)
+                  {
+                      retTypeSignature = TypeUtil.matchTypeParameterToArgument
+                          (type
+                             , retTypeSignature, typeDesc.getTypeParameterSignatures());
+                      
+                      if (retTypeSignature == null)
+                      {
+                          retTypeSignature = TypeConstants.TYPE_JAVAOBJECT;
+                      }
+                  }
+                  else
+                  {
+                    retTypeSignature = callMethod.getResolvedReturnTypeUnerased();
+                  }
+  
+                  final IPropertySymbol  propSymbol = 
+                      SymbolFactory.eINSTANCE.createIPropertySymbol();
+  
+                  // TODO: there is a possible problem here for non-string keyed maps
+                  propSymbol.setName(symbolName);
+                  propSymbol.setReadable(true);
+                  
+                  {
+                      IJavaTypeDescriptor2 newTypeDesc = null;
+                      
+                      if (retTypeSignature.equals(TypeConstants.TYPE_JAVAOBJECT))
+                      {
+                          newTypeDesc = SymbolFactory.eINSTANCE.createIBoundedJavaTypeDescriptor();
+                      }
+                      else
+                      {
+                          newTypeDesc = SymbolFactory.eINSTANCE.createIJavaTypeDescriptor2();
+                      }
+                      
+                      newTypeDesc.setArrayCount(Signature.getArrayCount(retTypeSignature));
+                      
+                      // may be null
+                      newTypeDesc.setType(typeDesc.resolveType(retTypeSignature));
+                      newTypeDesc.setTypeSignatureDelegate(retTypeSignature);
+                      propSymbol.setTypeDescriptor(newTypeDesc);
+                  }
+                  
+                  result = propSymbol;
+              } 
+              catch (JavaModelException e) 
+              {
+                  JSFCommonPlugin.log(e);
+                  // fall-through and return null result
+              }
             }
         }
 
         return result;
     }
 
-    static IMethod matchMethod(String methodName, List methodArguments, IMethod[] allMethods, List typeParameterSignatures)
+    static JDTBeanMethod matchMethod(String methodName, List methodArguments, JDTBeanMethod[] allMethods, List typeParameterSignatures)
     {
-//        final List argSigs = convertArgsToSignatures(methodArguments);
-        IMethod matchedMethod = null;
-
         for (int i = 0; i < allMethods.length; i++)
         {
-            final IMethod method = allMethods[i];
+            final JDTBeanMethod method = allMethods[i];
             
             // check for names and argument count match
-            if (method.getParameterTypes().length == methodArguments.size()
+            if (method.getResolvedParameterTypesUnerased().length == methodArguments.size()
                     && method.getElementName().equals(methodName))
             {
-                List<String> methods = resolveMethodParameters(method, typeParameterSignatures);
+                List<String> params = resolveMethodParameters(method, typeParameterSignatures);
                 
                 // need to verify argument matches
                 boolean isMatched = true;
-                CHECK_ARGUMENTS: for (int j = 0; j < methods.size(); j++)
+                CHECK_ARGUMENTS: for (int j = 0; j < params.size(); j++)
                 {
                     final ValueType valueType = (ValueType) methodArguments.get(j);
 
@@ -145,8 +140,8 @@
                     // - method name overloading
                     // - autoboxing primitives
                     // - certain kinds of parameterized args
-                    if (!methods.get(j).equals(valueType.getSignature())
-                         && !(methods.get(j).equals(TypeConstants.TYPE_JAVAOBJECT)
+                    if (!params.get(j).equals(valueType.getSignature())
+                         && !(params.get(j).equals(TypeConstants.TYPE_JAVAOBJECT)
                                  && Signature.getTypeSignatureKind(valueType.getSignature())==Signature.CLASS_TYPE_SIGNATURE))
                     {
                         // not a match
@@ -162,18 +157,15 @@
             }
         }
 
-        return matchedMethod;
+        return null;
     }
     
-    static List<String> resolveMethodParameters(IMethod method, List typeParametersSignatures)
+    static List<String> resolveMethodParameters(JDTBeanMethod method, List typeParametersSignatures)
     {
         List<String>   resolved = new ArrayList<String>();
-        String[] parameterTypes = method.getParameterTypes();
+        String[] parameterTypes = method.getResolvedParameterTypesUnerased();
         for (String parameter : parameterTypes)
         { 
-            parameter = TypeUtil.resolveTypeSignature(method.getDeclaringType()
-                    , parameter, false);
-            
             if (Signature.getTypeSignatureKind(parameter) == Signature.TYPE_VARIABLE_SIGNATURE)
             {
                 parameter = TypeUtil.matchTypeParameterToArgument
diff --git a/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/core/jsfappconfig/AnnotationSearchRequestor.java b/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/core/jsfappconfig/AnnotationSearchRequestor.java
index 2ce5af6..7d2ed42 100644
--- a/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/core/jsfappconfig/AnnotationSearchRequestor.java
+++ b/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/core/jsfappconfig/AnnotationSearchRequestor.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2011, 2012 Oracle Corporation.
+ * Copyright (c) 2011, 2021 Oracle Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -8,31 +8,33 @@
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
- *    Andrew McCulloch - initial API and implementation
- *    Ian Trimble - maintenance
+ *        Andrew McCulloch        - initial API and implementation
+ *        Ian Trimble                 - maintenance
+ *        Reto Weiss/Axon Ivy - Use cached JDTBeanIntrospector to resolve annotation types
  *******************************************************************************/ 
 package org.eclipse.jst.jsf.core.jsfappconfig;
 
-import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.MANAGED_BEAN_ANNOTATION_CLASS;
-import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.REFERENCED_BEAN_ANNOTATION_CLASS;
+import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.APPLICATION_SCOPED_ANNOTATION_CLASS;
+import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CDI_APPLICATION_SCOPED_ANNOTATION_CLASS;
+import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CDI_CONVERSATION_SCOPED_ANNOTATION_CLASS;
+import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CDI_MODEL_BEAN_ANNOTATION_CLASS;
+import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CDI_NAMED_BEAN_ANNOTATION_CLASS;
+import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CDI_REQUEST_SCOPED_ANNOTATION_CLASS;
+import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CDI_SESSION_SCOPED_ANNOTATION_CLASS;
+import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CUSTOM_SCOPED_ANNOTATION_CLASS;
 import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.FACES_COMPONENT_ANNOTATION_CLASS;
 import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.FACES_CONVERTER_ANNOTATION_CLASS;
 import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.FACES_RENDERER_ANNOTATION_CLASS;
 import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.FACES_VALIDATOR_ANNOTATION_CLASS;
-
+import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.MANAGED_BEAN_ANNOTATION_CLASS;
 import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.NONE_SCOPED_ANNOTATION_CLASS;
-import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.VIEW_SCOPED_ANNOTATION_CLASS;
+import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.REFERENCED_BEAN_ANNOTATION_CLASS;
 import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.SESSION_SCOPED_ANNOTATION_CLASS;
-import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.APPLICATION_SCOPED_ANNOTATION_CLASS;
-import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CUSTOM_SCOPED_ANNOTATION_CLASS;
+import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.VIEW_SCOPED_ANNOTATION_CLASS;
 
-import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CDI_NAMED_BEAN_ANNOTATION_CLASS;
-import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CDI_MODEL_BEAN_ANNOTATION_CLASS;
-
-import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CDI_REQUEST_SCOPED_ANNOTATION_CLASS;
-import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CDI_CONVERSATION_SCOPED_ANNOTATION_CLASS;
-import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CDI_SESSION_SCOPED_ANNOTATION_CLASS;
-import static org.eclipse.jst.jsf.core.jsfappconfig.AnnotationJSFAppConfigProvider.CDI_APPLICATION_SCOPED_ANNOTATION_CLASS;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
 
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.emf.common.util.EList;
@@ -40,8 +42,10 @@
 import org.eclipse.jdt.core.IMemberValuePair;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.Signature;
 import org.eclipse.jdt.core.search.SearchMatch;
 import org.eclipse.jdt.core.search.SearchRequestor;
+import org.eclipse.jst.jsf.common.util.JDTBeanIntrospector;
 import org.eclipse.jst.jsf.facesconfig.emf.ComponentClassType;
 import org.eclipse.jst.jsf.facesconfig.emf.ComponentFamilyType;
 import org.eclipse.jst.jsf.facesconfig.emf.ComponentType;
@@ -71,76 +75,163 @@
 /**
  * SearchRequestor that looks at annotations for JSF configuration.
  * 
- * <p><b>Provisional API - subject to change</b></p>
+ * <p>
+ * <b>Provisional API - subject to change</b>
+ * </p>
  * 
  * @author Andrew McCulloch - Oracle
  */
-public class AnnotationSearchRequestor extends SearchRequestor {
-    
+public class AnnotationSearchRequestor extends SearchRequestor
+{
     private final FacesConfigType facesConfig;
     
-    AnnotationSearchRequestor(final FacesConfigType facesConfig) {
-         this.facesConfig = facesConfig;
-    }
+    private static final Set<String> ANNOATION_CANDIDATES = ofAnnotation(
+            MANAGED_BEAN_ANNOTATION_CLASS, 
+            REFERENCED_BEAN_ANNOTATION_CLASS, 
+            FACES_COMPONENT_ANNOTATION_CLASS, 
+            FACES_CONVERTER_ANNOTATION_CLASS, 
+            FACES_RENDERER_ANNOTATION_CLASS,
+            FACES_VALIDATOR_ANNOTATION_CLASS, 
+            CDI_NAMED_BEAN_ANNOTATION_CLASS, 
+            CDI_MODEL_BEAN_ANNOTATION_CLASS);
     
-    public void acceptSearchMatch(SearchMatch match) throws CoreException {
-        if (match.getAccuracy() == SearchMatch.A_ACCURATE) {
-            Object element = match.getElement();
-            if (element instanceof IType) {
-                IType type = (IType) element;
-                IAnnotation[] annotations = type.getAnnotations();
-                if (annotations != null) {
-                    for (int i = 0, k = annotations.length; i < k; i++) {
-                        if (annotations[i].exists()) {
-                            String annotationType = annotations[i].getElementName();
-                            String[][] resolvedAnnotationTypes = type.resolveType(annotationType);
-                            if (resolvedAnnotationTypes != null) {
-                                String resolvedAnnotationClassName = new StringBuffer(resolvedAnnotationTypes[0][0]).append('.').append(resolvedAnnotationTypes[0][1]).toString();
-                                if (MANAGED_BEAN_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                                    addManagedBean(annotations[i], type);
-                                } else if (REFERENCED_BEAN_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                                    addReferencedBean(annotations[i], type);
-                                } else if (FACES_COMPONENT_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                                    addComponent(annotations[i], type);
-                                } else if (FACES_CONVERTER_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                                    addConverter(annotations[i], type);
-                                } else if (FACES_RENDERER_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                                    addRenderer(annotations[i], type);
-                                } else if (FACES_VALIDATOR_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                                    addValidator(annotations[i], type);
-                                } else if (CDI_NAMED_BEAN_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                                	addCDINamedBean(annotations[i], type);
-                                } else if (CDI_MODEL_BEAN_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                                	addCDIModelBean(type);
-                                }
-                            }
-                        }
-                    }
-                }
+    private static final Set<String> SCOPED_ANNOTATION_CANDIDATES = ofAnnotation(
+            NONE_SCOPED_ANNOTATION_CLASS,
+            VIEW_SCOPED_ANNOTATION_CLASS,
+            SESSION_SCOPED_ANNOTATION_CLASS,
+            APPLICATION_SCOPED_ANNOTATION_CLASS,
+            CUSTOM_SCOPED_ANNOTATION_CLASS);
+
+    private static final Set<String> CDI_SCOPED_ANNOTATION_CANDIDATES = ofAnnotation(
+            CDI_REQUEST_SCOPED_ANNOTATION_CLASS,
+            CDI_CONVERSATION_SCOPED_ANNOTATION_CLASS,
+            CDI_SESSION_SCOPED_ANNOTATION_CLASS,
+            CDI_APPLICATION_SCOPED_ANNOTATION_CLASS);
+ 
+    private static Set<String> ofAnnotation(String... annotationClasses)
+    {
+        Set<String> candidates = new HashSet<String>();
+        for (String annotationClass : annotationClasses)
+        {
+            candidates.add(annotationClass);
+            candidates.add(Signature.getSimpleName(annotationClass));
+        }
+        return Collections.unmodifiableSet(candidates);
+    }
+
+    AnnotationSearchRequestor(final FacesConfigType facesConfig)
+    {
+        this.facesConfig = facesConfig;
+    }
+
+    @Override
+    public void acceptSearchMatch(SearchMatch match) throws CoreException
+    {
+        if (match.getAccuracy() != SearchMatch.A_ACCURATE)
+        {
+            return;
+        }
+
+        Object element = match.getElement();
+        if (!(element instanceof IType))
+        {
+            return;
+        }
+        IType type = (IType) element;
+        JDTBeanIntrospector beanIntrospector = JDTBeanIntrospector.forType(type);
+        IAnnotation[] annotations = type.getAnnotations();
+        if (annotations == null)
+        {
+            return;
+        }
+        for (IAnnotation annotation : annotations)
+        {
+            processAnnotation(type, beanIntrospector, annotation);
+        }
+    }
+
+    private void processAnnotation(IType type, JDTBeanIntrospector beanIntrospector, IAnnotation annotation) throws CoreException
+    {
+        if (!annotation.exists())
+        {
+            return;
+        }
+        String annotationType = annotation.getElementName();
+        if (! isAnnotationCandidate(annotationType))
+        {
+            return;
+        }
+        String annotationClassName = beanIntrospector.resolveFullQualifiedTypeName(annotationType);
+        if (annotationClassName != null)
+        {
+            if (MANAGED_BEAN_ANNOTATION_CLASS.equals(annotationClassName))
+            {
+                addManagedBean(annotation, type, beanIntrospector);
+            }
+            else if (REFERENCED_BEAN_ANNOTATION_CLASS.equals(annotationClassName))
+            {
+                addReferencedBean(annotation, type);
+            }
+            else if (FACES_COMPONENT_ANNOTATION_CLASS.equals(annotationClassName))
+            {
+                addComponent(annotation, type);
+            }
+            else if (FACES_CONVERTER_ANNOTATION_CLASS.equals(annotationClassName))
+            {
+                addConverter(annotation, type);
+            }
+            else if (FACES_RENDERER_ANNOTATION_CLASS.equals(annotationClassName))
+            {
+                addRenderer(annotation, type);
+            }
+            else if (FACES_VALIDATOR_ANNOTATION_CLASS.equals(annotationClassName))
+            {
+                addValidator(annotation, type);
+            }
+            else if (CDI_NAMED_BEAN_ANNOTATION_CLASS.equals(annotationClassName))
+            {
+                addCDINamedBean(annotation, beanIntrospector, type);
+            }
+            else if (CDI_MODEL_BEAN_ANNOTATION_CLASS.equals(annotationClassName))
+            {
+                addCDIModelBean(type);
             }
         }
     }
 
-    private void addReferencedBean(IAnnotation referencedBeanAnnotation, IType beanType) throws JavaModelException {
+    private boolean isAnnotationCandidate(String annotationType)
+    {
+        return ANNOATION_CANDIDATES.contains(annotationType);
+    }
+
+    private void addReferencedBean(IAnnotation referencedBeanAnnotation, IType beanType)
+                    throws JavaModelException
+    {
         IMemberValuePair[] pairs = referencedBeanAnnotation.getMemberValuePairs();
         String beanNameString = null;
-        if (pairs != null) {
-            for (IMemberValuePair pair : pairs) {
-                if ("name".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) { //$NON-NLS-1$
-                    beanNameString = (String)pair.getValue();
+        if (pairs != null)
+        {
+            for (IMemberValuePair pair : pairs)
+            {
+                if ("name".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) //$NON-NLS-1$
+                {
+                    beanNameString = (String) pair.getValue();
                 }
             }
         }
-        if (beanNameString == null) {
+        if (beanNameString == null)
+        {
             beanNameString = beanType.getElementName();
-            if (beanNameString != null && beanNameString.length() > 0) {
+            if (beanNameString != null && beanNameString.length() > 0)
+            {
                 StringBuffer casedName = new StringBuffer(String.valueOf(beanNameString.charAt(0)).toUpperCase());
                 beanNameString = casedName.append(beanNameString.substring(1)).toString();
             }
         }
         String beanClassName = beanType.getFullyQualifiedName();
 
-        if (beanNameString != null && beanClassName != null) {
+        if (beanNameString != null && beanClassName != null)
+        {
             ReferencedBeanType bean = FacesConfigFactory.eINSTANCE.createReferencedBeanType();
             ReferencedBeanNameType beanName = FacesConfigFactory.eINSTANCE.createReferencedBeanNameType();
             beanName.setTextContent(beanNameString);
@@ -152,57 +243,40 @@
         }
     }
 
-    private void addManagedBean(IAnnotation beanAnnotation, IType beanType) throws JavaModelException {
+    private void addManagedBean(IAnnotation beanAnnotation, IType beanType, JDTBeanIntrospector beanIntrospector) throws JavaModelException
+    {
         IMemberValuePair[] pairs = beanAnnotation.getMemberValuePairs();
         String beanNameString = null;
         Boolean isBeanEager = Boolean.FALSE;
-        if (pairs != null) {
-            for (IMemberValuePair pair : pairs) {
-                if ("name".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) { //$NON-NLS-1$
-                    beanNameString = (String)pair.getValue();
-                } else if ("eager".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_BOOLEAN) { //$NON-NLS-1$
-                    isBeanEager = (Boolean)pair.getValue();
+        if (pairs != null)
+        {
+            for (IMemberValuePair pair : pairs)
+            {
+                if ("name".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) //$NON-NLS-1$
+                {
+                    beanNameString = (String) pair.getValue();
+                }
+                else if ("eager".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_BOOLEAN) //$NON-NLS-1$
+                {
+                    isBeanEager = (Boolean) pair.getValue();
                 }
             }
         }
-        if (beanNameString == null || beanNameString.length() < 1) {
+        if (beanNameString == null || beanNameString.length() < 1)
+        {
             beanNameString = beanType.getElementName();
-            if (beanNameString != null && beanNameString.length() > 0) {
+            if (beanNameString != null && beanNameString.length() > 0)
+            {
                 StringBuffer casedName = new StringBuffer(String.valueOf(beanNameString.charAt(0)).toLowerCase());
                 beanNameString = casedName.append(beanNameString.substring(1)).toString();
             }
         }
         String beanClassName = beanType.getFullyQualifiedName();
 
-        String beanScopeString = "request"; //$NON-NLS-1$
-        IAnnotation[] annotations = beanType.getAnnotations();
-        if (annotations != null) {
-	        for (int i = 0, k = annotations.length; i < k; i++) {
-                if (annotations[i].exists()) {
-                    String annotationType = annotations[i].getElementName();
-                    String[][] resolvedAnnotationTypes = beanType.resolveType(annotationType);
-                    if (resolvedAnnotationTypes != null) {
-                        String resolvedAnnotationClassName = new StringBuffer(resolvedAnnotationTypes[0][0]).append('.').append(resolvedAnnotationTypes[0][1]).toString();
-                        if (NONE_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                        	beanScopeString = "none"; //$NON-NLS-1$
-                        } else if (VIEW_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                        	beanScopeString = "view"; //$NON-NLS-1$
-                        } else if (SESSION_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                        	beanScopeString = "session"; //$NON-NLS-1$
-                        } else if (APPLICATION_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                        	beanScopeString = "application"; //$NON-NLS-1$
-                        } else if (CUSTOM_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                            IMemberValuePair[] scopePairs = annotations[i].getMemberValuePairs();
-                            if (scopePairs != null && scopePairs.length == 1 && scopePairs[0].getValueKind() == IMemberValuePair.K_STRING) {
-                                beanScopeString = (String)scopePairs[0].getValue();
-                            }
-                        }
-                    }
-                }
-	        }
-        }
+        String beanScopeString = processScopeAnnotations(beanType, beanIntrospector);
 
-        if (beanNameString != null && beanClassName != null) {
+        if (beanNameString != null && beanClassName != null)
+        {
             ManagedBeanType bean = FacesConfigFactory.eINSTANCE.createManagedBeanType();
             ManagedBeanNameType beanName = FacesConfigFactory.eINSTANCE.createManagedBeanNameType();
             beanName.setTextContent(beanNameString);
@@ -219,88 +293,176 @@
         }
     }
 
-    private void addValidator(IAnnotation validatorAnnotation, IType validatorType) throws JavaModelException {
+    private String processScopeAnnotations(IType beanType, JDTBeanIntrospector beanIntrospector) throws JavaModelException
+    {
+        String beanScopeString = "request"; //$NON-NLS-1$
+        IAnnotation[] annotations = beanType.getAnnotations();
+        if (annotations == null)
+        {
+            return beanScopeString;
+        }
+        for (IAnnotation annotation : annotations)
+        {
+            String scope = processScopeAnnoation(beanType, beanIntrospector, annotation);
+            if (scope != null)
+            {
+                beanScopeString = scope;
+            }
+        }
+        return beanScopeString;
+    }
+
+    private String processScopeAnnoation(IType beanType, JDTBeanIntrospector beanIntrospector, IAnnotation annotation) throws JavaModelException
+    {
+        if (! annotation.exists())
+        {
+            return null;
+        }
+        String annotationType = annotation.getElementName();
+        if (! isScopeAnnotationCandidate(annotationType))
+        {
+            return null;
+        }
+        String annotationClassName = beanIntrospector.resolveFullQualifiedTypeName(annotationType);
+        if (annotationClassName == null)
+        {
+            return null;
+        }
+        if (NONE_SCOPED_ANNOTATION_CLASS.equals(annotationClassName))
+        {
+            return "none"; //$NON-NLS-1$
+        }
+        else if (VIEW_SCOPED_ANNOTATION_CLASS.equals(annotationClassName))
+        {
+            return "view"; //$NON-NLS-1$
+        }
+        else if (SESSION_SCOPED_ANNOTATION_CLASS.equals(annotationClassName))
+        {
+            return "session"; //$NON-NLS-1$
+        }
+        else if (APPLICATION_SCOPED_ANNOTATION_CLASS.equals(annotationClassName))
+        {
+            return "application"; //$NON-NLS-1$
+        }
+        else if (CUSTOM_SCOPED_ANNOTATION_CLASS.equals(annotationClassName))
+        {
+            IMemberValuePair[] scopePairs = annotation.getMemberValuePairs();
+            if (scopePairs != null && scopePairs.length == 1
+                            && scopePairs[0].getValueKind() == IMemberValuePair.K_STRING)
+            {
+                return (String) scopePairs[0].getValue();
+            }
+        }
+        return null;
+    }
+
+    private boolean isScopeAnnotationCandidate(String annotationType)
+    {
+        return SCOPED_ANNOTATION_CANDIDATES.contains(annotationType);
+    }
+
+    private void addValidator(IAnnotation validatorAnnotation, IType validatorType) throws JavaModelException
+    {
         String validatorClassName = validatorType.getFullyQualifiedName();
         IMemberValuePair[] pairs = validatorAnnotation.getMemberValuePairs();
         String validatorIDString = null;
-//        Boolean isDefaultBoolean = null;
-        if (pairs != null) {
-            for (IMemberValuePair pair : pairs) {
-                if ("value".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) { //$NON-NLS-1$
-                    validatorIDString = (String)pair.getValue();
-                    //isDefault not used in emf model
-//                } else if ("isDefault".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_BOOLEAN) {  //$NON-NLS-1$
-//                    isDefaultBoolean = (Boolean)pair.getValue();
+        // Boolean isDefaultBoolean = null;
+        if (pairs != null)
+        {
+            for (IMemberValuePair pair : pairs)
+            {
+                if ("value".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) //$NON-NLS-1$
+                {
+                    validatorIDString = (String) pair.getValue();
+                    // isDefault not used in emf model
+                    // } else if ("isDefault".equals(pair.getMemberName()) &&
+                    // pair.getValueKind() == IMemberValuePair.K_BOOLEAN) { //$NON-NLS-1$
+                    // isDefaultBoolean = (Boolean)pair.getValue();
                 }
             }
         }
-        
-        if (validatorClassName != null && validatorIDString != null) {
+
+        if (validatorClassName != null && validatorIDString != null)
+        {
             ValidatorType validator = FacesConfigFactory.eINSTANCE.createValidatorType();
             ValidatorClassType validatorClass = FacesConfigFactory.eINSTANCE.createValidatorClassType();
             validatorClass.setTextContent(validatorClassName);
             validator.setValidatorClass(validatorClass);
-            
+
             ValidatorIdType validatorID = FacesConfigFactory.eINSTANCE.createValidatorIdType();
             validatorID.setTextContent(validatorIDString);
             validator.setValidatorId(validatorID);
-            
 
-//          if (isDefaultBoolean == null) {
-//              isDefaultBoolean = Boolean.FALSE;
-//          }
-            
+            // if (isDefaultBoolean == null) {
+            // isDefaultBoolean = Boolean.FALSE;
+            // }
+
             facesConfig.getValidator().add(validator);
         }
     }
 
-    private void addRenderer(IAnnotation rendererAnnotation, IType rendererType) throws JavaModelException {
+    private void addRenderer(IAnnotation rendererAnnotation, IType rendererType) throws JavaModelException
+    {
         String rendererClassName = rendererType.getFullyQualifiedName();
         IMemberValuePair[] pairs = rendererAnnotation.getMemberValuePairs();
         String rendererTypeString = null;
         String componentFamilyString = null;
         String renderKitIDString = null;
-        if (pairs != null) {
-            for (IMemberValuePair pair : pairs) {
-                if ("rendererType".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) { //$NON-NLS-1$
-                    rendererTypeString = (String)pair.getValue();
-                } else if ("componentFamily".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) {  //$NON-NLS-1$
-                    componentFamilyString = (String)pair.getValue();
-                } else if ("renderKitId".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) {  //$NON-NLS-1$
-                    renderKitIDString = (String)pair.getValue();
+        if (pairs != null)
+        {
+            for (IMemberValuePair pair : pairs)
+            {
+                if ("rendererType".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) //$NON-NLS-1$
+                {
+                    rendererTypeString = (String) pair.getValue();
+                }
+                else if ("componentFamily".equals(pair.getMemberName()) //$NON-NLS-1$
+                                && pair.getValueKind() == IMemberValuePair.K_STRING)
+                {
+                    componentFamilyString = (String) pair.getValue();
+                }
+                else if ("renderKitId".equals(pair.getMemberName()) //$NON-NLS-1$
+                                && pair.getValueKind() == IMemberValuePair.K_STRING)
+                {
+                    renderKitIDString = (String) pair.getValue();
                 }
             }
         }
-        
-        if (rendererClassName != null && rendererTypeString != null && componentFamilyString != null) {
+
+        if (rendererClassName != null && rendererTypeString != null && componentFamilyString != null)
+        {
             RendererType renderer = FacesConfigFactory.eINSTANCE.createRendererType();
             RendererClassType rendererClass = FacesConfigFactory.eINSTANCE.createRendererClassType();
             rendererClass.setTextContent(rendererClassName);
             renderer.setRendererClass(rendererClass);
 
-
             RendererTypeType rendererTypeType = FacesConfigFactory.eINSTANCE.createRendererTypeType();
             rendererTypeType.setTextContent(rendererTypeString);
             renderer.setRendererType(rendererTypeType);
-            
+
             ComponentFamilyType componentFamily = FacesConfigFactory.eINSTANCE.createComponentFamilyType();
             componentFamily.setTextContent(componentFamilyString);
             renderer.setComponentFamily(componentFamily);
 
-            
-            if (renderKitIDString == null) {
-                //use the default
+            if (renderKitIDString == null)
+            {
+                // use the default
                 renderKitIDString = "HTML_BASIC"; //$NON-NLS-1$
             }
             EList renderKits = facesConfig.getRenderKit();
-            if (renderKits != null) {
+            if (renderKits != null)
+            {
                 RenderKitType renderKit = null;
-                for (int i = 0, k = renderKits.size(); i < k; i++) {
-                    if (((RenderKitType)renderKits.get(i)).getRenderKitId() != null && renderKitIDString.equals(((RenderKitType)renderKits.get(i)).getRenderKitId().getTextContent())) {
-                        renderKit = (RenderKitType)(renderKits.get(i));
+                for (int i = 0, k = renderKits.size(); i < k; i++)
+                {
+                    if (((RenderKitType) renderKits.get(i)).getRenderKitId() != null && renderKitIDString
+                                    .equals(((RenderKitType) renderKits.get(i)).getRenderKitId().getTextContent()))
+                    {
+                        renderKit = (RenderKitType) (renderKits.get(i));
                     }
                 }
-                if (renderKit == null) {
+                if (renderKit == null)
+                {
                     renderKit = FacesConfigFactory.eINSTANCE.createRenderKitType();
                     RenderKitIdType renderKitID = FacesConfigFactory.eINSTANCE.createRenderKitIdType();
                     renderKitID.setTextContent(renderKitIDString);
@@ -312,34 +474,43 @@
         }
     }
 
-    private void addConverter(IAnnotation converterAnnotation, IType converterType) throws JavaModelException {
+    private void addConverter(IAnnotation converterAnnotation, IType converterType) throws JavaModelException
+    {
         String converterClassName = converterType.getFullyQualifiedName();
         IMemberValuePair[] pairs = converterAnnotation.getMemberValuePairs();
         String converterIDString = null;
         String converterForClassString = null;
-        if (pairs != null) {
-            for (IMemberValuePair pair : pairs) {
-                if ("value".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) { //$NON-NLS-1$
-                    converterIDString = (String)pair.getValue();
-                } else if ("forClass".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_CLASS) {  //$NON-NLS-1$
-                    converterForClassString = (String)pair.getValue();
+        if (pairs != null)
+        {
+            for (IMemberValuePair pair : pairs)
+            {
+                if ("value".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) //$NON-NLS-1$
+                {
+                    converterIDString = (String) pair.getValue();
+                }
+                else if ("forClass".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_CLASS) //$NON-NLS-1$
+                {
+                    converterForClassString = (String) pair.getValue();
                 }
             }
         }
-        if (converterClassName != null) {
+        if (converterClassName != null)
+        {
             ConverterType converter = FacesConfigFactory.eINSTANCE.createConverterType();
             ConverterClassType converterClass = FacesConfigFactory.eINSTANCE.createConverterClassType();
             converterClass.setTextContent(converterClassName);
             converter.setConverterClass(converterClass);
 
-            if (converterIDString != null) {
+            if (converterIDString != null)
+            {
                 ConverterIdType converterID = FacesConfigFactory.eINSTANCE.createConverterIdType();
                 converterID.setTextContent(converterIDString);
                 converter.setConverterId(converterID);
-            }  
-            
-            if (converterForClassString == null) {
-                //use the default
+            }
+
+            if (converterForClassString == null)
+            {
+                // use the default
                 converterForClassString = "java.lang.Object"; //$NON-NLS-1$
             }
             ConverterForClassType converterForClass = FacesConfigFactory.eINSTANCE.createConverterForClassType();
@@ -349,45 +520,56 @@
         }
     }
 
-    private void addComponent(IAnnotation componentAnnotation, IType componentType) throws JavaModelException {
+    private void addComponent(IAnnotation componentAnnotation, IType componentType) throws JavaModelException
+    {
         String componentClassName = componentType.getFullyQualifiedName();
         IMemberValuePair[] pairs = componentAnnotation.getMemberValuePairs();
         String componentTypeString = null;
-        if (pairs != null) {
-            for (IMemberValuePair pair : pairs) {
-                if ("value".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) { //$NON-NLS-1$
-                    componentTypeString = (String)pair.getValue();
+        if (pairs != null)
+        {
+            for (IMemberValuePair pair : pairs)
+            {
+                if ("value".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) //$NON-NLS-1$
+                {
+                    componentTypeString = (String) pair.getValue();
                 }
             }
         }
-        if (componentTypeString != null && componentClassName != null) {
-            ComponentType component =  FacesConfigFactory.eINSTANCE.createComponentType();
+        if (componentTypeString != null && componentClassName != null)
+        {
+            ComponentType component = FacesConfigFactory.eINSTANCE.createComponentType();
             ComponentClassType componentClass = FacesConfigFactory.eINSTANCE.createComponentClassType();
             componentClass.setTextContent(componentClassName);
             component.setComponentClass(componentClass);
-            
+
             ComponentTypeType componentTypeType = FacesConfigFactory.eINSTANCE.createComponentTypeType();
             componentTypeType.setTextContent(componentTypeString);
             component.setComponentType(componentTypeType);
-            
+
             facesConfig.getComponent().add(component);
         }
     }
 
-    private void addCDINamedBean(IAnnotation beanAnnotation, IType beanType) throws JavaModelException {
+    private void addCDINamedBean(IAnnotation beanAnnotation, JDTBeanIntrospector beanIntrospector, IType beanType) throws JavaModelException
+    {
         IMemberValuePair[] pairs = beanAnnotation.getMemberValuePairs();
 
         String beanNameString = null;
-        if (pairs != null) {
-            for (IMemberValuePair pair : pairs) {
-                if ("value".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) { //$NON-NLS-1$
-                    beanNameString = (String)pair.getValue();
+        if (pairs != null)
+        {
+            for (IMemberValuePair pair : pairs)
+            {
+                if ("value".equals(pair.getMemberName()) && pair.getValueKind() == IMemberValuePair.K_STRING) //$NON-NLS-1$
+                {
+                    beanNameString = (String) pair.getValue();
                 }
             }
         }
-        if (beanNameString == null || beanNameString.length() < 1) {
+        if (beanNameString == null || beanNameString.length() < 1)
+        {
             beanNameString = beanType.getElementName();
-            if (beanNameString != null && beanNameString.length() > 0) {
+            if (beanNameString != null && beanNameString.length() > 0)
+            {
                 StringBuffer casedName = new StringBuffer(String.valueOf(beanNameString.charAt(0)).toLowerCase());
                 beanNameString = casedName.append(beanNameString.substring(1)).toString();
             }
@@ -395,30 +577,10 @@
 
         String beanClassName = beanType.getFullyQualifiedName();
 
-        String beanScopeString = "dependent"; //$NON-NLS-1$
-        IAnnotation[] annotations = beanType.getAnnotations();
-        if (annotations != null) {
-	        for (int i = 0, k = annotations.length; i < k; i++) {
-                if (annotations[i].exists()) {
-                    String annotationType = annotations[i].getElementName();
-                    String[][] resolvedAnnotationTypes = beanType.resolveType(annotationType);
-                    if (resolvedAnnotationTypes != null) {
-                        String resolvedAnnotationClassName = new StringBuffer(resolvedAnnotationTypes[0][0]).append('.').append(resolvedAnnotationTypes[0][1]).toString();
-                        if (CDI_REQUEST_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                        	beanScopeString = "request"; //$NON-NLS-1$
-                        } else if (CDI_CONVERSATION_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                        	beanScopeString = "conversation"; //$NON-NLS-1$
-                        } else if (CDI_SESSION_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                        	beanScopeString = "session"; //$NON-NLS-1$
-                        } else if (CDI_APPLICATION_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                        	beanScopeString = "application"; //$NON-NLS-1$
-                        }
-                    }
-                }
-	        }
-        }
+        String beanScopeString = processCDIScopeAnnotations(beanType, beanIntrospector);
 
-        if (beanNameString != null && beanClassName != null) {
+        if (beanNameString != null && beanClassName != null)
+        {
             ManagedBeanType bean = FacesConfigFactory.eINSTANCE.createManagedBeanType();
             ManagedBeanNameType beanName = FacesConfigFactory.eINSTANCE.createManagedBeanNameType();
             beanName.setTextContent(beanNameString);
@@ -435,9 +597,70 @@
         }
     }
 
-    private void addCDIModelBean(IType beanType) throws JavaModelException {
+    private String processCDIScopeAnnotations(IType beanType, JDTBeanIntrospector beanIntrospector) throws JavaModelException
+    {
+        String beanScopeString = "dependent"; //$NON-NLS-1$
+        IAnnotation[] annotations = beanType.getAnnotations();
+        if (annotations == null)
+        {
+            return beanScopeString;
+        }
+        for (IAnnotation annotation : annotations)
+        {
+            String scope = processCDIScopeAnnotation(beanType, beanIntrospector, annotation);
+            if (scope != null)
+            {
+                beanScopeString = scope;
+            }
+        }
+        return beanScopeString;
+    }
+    
+    private String processCDIScopeAnnotation(IType beanType, JDTBeanIntrospector beanIntrospector, IAnnotation annotation)
+    {
+        if (!annotation.exists())
+        {
+            return null;
+        }
+        String annotationType = annotation.getElementName();
+        if (! isCDIScopeAnnotationCandidate(annotationType))
+        {
+            return null;
+        }
+        String annotationClassName = beanIntrospector.resolveFullQualifiedTypeName(annotationType);
+        if (annotationClassName == null)
+        {
+            return null;
+        }
+        if (CDI_REQUEST_SCOPED_ANNOTATION_CLASS.equals(annotationClassName))
+        {
+            return "request"; //$NON-NLS-1$
+        }
+        else if (CDI_CONVERSATION_SCOPED_ANNOTATION_CLASS.equals(annotationClassName))
+        {
+            return "conversation"; //$NON-NLS-1$
+        }
+        else if (CDI_SESSION_SCOPED_ANNOTATION_CLASS.equals(annotationClassName))
+        {
+            return "session"; //$NON-NLS-1$
+        }
+        else if (CDI_APPLICATION_SCOPED_ANNOTATION_CLASS.equals(annotationClassName))
+        {
+            return "application"; //$NON-NLS-1$
+        }
+        return null;
+    }
+
+    private boolean isCDIScopeAnnotationCandidate(String annotationType)
+    {
+        return CDI_SCOPED_ANNOTATION_CANDIDATES.contains(annotationType);
+    }
+
+    private void addCDIModelBean(IType beanType) throws JavaModelException
+    {
         String beanNameString = beanType.getElementName();
-        if (beanNameString != null && beanNameString.length() > 0) {
+        if (beanNameString != null && beanNameString.length() > 0)
+        {
             StringBuffer casedName = new StringBuffer(String.valueOf(beanNameString.charAt(0)).toLowerCase());
             beanNameString = casedName.append(beanNameString.substring(1)).toString();
         }
@@ -446,26 +669,37 @@
 
         String beanScopeString = "request"; //$NON-NLS-1$
         IAnnotation[] annotations = beanType.getAnnotations();
-        if (annotations != null) {
-	        for (int i = 0, k = annotations.length; i < k; i++) {
-                if (annotations[i].exists()) {
+        if (annotations != null)
+        {
+            for (int i = 0, k = annotations.length; i < k; i++)
+            {
+                if (annotations[i].exists())
+                {
                     String annotationType = annotations[i].getElementName();
                     String[][] resolvedAnnotationTypes = beanType.resolveType(annotationType);
-                    if (resolvedAnnotationTypes != null) {
-                        String resolvedAnnotationClassName = new StringBuffer(resolvedAnnotationTypes[0][0]).append('.').append(resolvedAnnotationTypes[0][1]).toString();
-                        if (CDI_CONVERSATION_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                        	beanScopeString = "conversation"; //$NON-NLS-1$
-                        } else if (CDI_SESSION_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                        	beanScopeString = "session"; //$NON-NLS-1$
-                        } else if (CDI_APPLICATION_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName)) {
-                        	beanScopeString = "application"; //$NON-NLS-1$
+                    if (resolvedAnnotationTypes != null)
+                    {
+                        String resolvedAnnotationClassName = new StringBuffer(resolvedAnnotationTypes[0][0]).append('.')
+                                        .append(resolvedAnnotationTypes[0][1]).toString();
+                        if (CDI_CONVERSATION_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName))
+                        {
+                            beanScopeString = "conversation"; //$NON-NLS-1$
+                        }
+                        else if (CDI_SESSION_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName))
+                        {
+                            beanScopeString = "session"; //$NON-NLS-1$
+                        }
+                        else if (CDI_APPLICATION_SCOPED_ANNOTATION_CLASS.equals(resolvedAnnotationClassName))
+                        {
+                            beanScopeString = "application"; //$NON-NLS-1$
                         }
                     }
                 }
-	        }
+            }
         }
 
-        if (beanNameString != null && beanClassName != null) {
+        if (beanNameString != null && beanClassName != null)
+        {
             ManagedBeanType bean = FacesConfigFactory.eINSTANCE.createManagedBeanType();
             ManagedBeanNameType beanName = FacesConfigFactory.eINSTANCE.createManagedBeanNameType();
             beanName.setTextContent(beanNameString);
diff --git a/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/designtime/internal/view/DTComponentIntrospector.java b/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/designtime/internal/view/DTComponentIntrospector.java
index 3a9b89a..8a12976 100644
--- a/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/designtime/internal/view/DTComponentIntrospector.java
+++ b/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/designtime/internal/view/DTComponentIntrospector.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2011 Oracle Corporation and others.
+ * Copyright (c) 2001, 2021 Oracle Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -8,7 +8,8 @@
  * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
- *     Oracle Corporation - initial API and implementation
+ *     Oracle Corporation  - initial API and implementation
+ *     Reto Weiss/Axon Ivy - Use cached JDTBeanIntrospector 
  *******************************************************************************/
 package org.eclipse.jst.jsf.designtime.internal.view;
 
@@ -357,9 +358,7 @@
 
             if (type != null)
             {
-                // TODO: should be able to use type cache for this
-                final JDTBeanIntrospector introspector = new JDTBeanIntrospector(
-                        type);
+                final JDTBeanIntrospector introspector = JDTBeanIntrospector.forType(type);
                 properties = introspector.getProperties();
             }
         }
diff --git a/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/validation/internal/appconfig/PropertyNameValidationVisitor.java b/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/validation/internal/appconfig/PropertyNameValidationVisitor.java
index 3c3d3f2..0d949a0 100644
--- a/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/validation/internal/appconfig/PropertyNameValidationVisitor.java
+++ b/jsf/plugins/org.eclipse.jst.jsf.core/src/org/eclipse/jst/jsf/validation/internal/appconfig/PropertyNameValidationVisitor.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2010 Oracle Corporation and others.
+ * Copyright (c) 2001, 2021 Oracle Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -8,7 +8,8 @@
  * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
- *     Oracle Corporation - initial API and implementation
+ *     Oracle Corporation  - initial API and implementation
+ *     Reto Weiss/Axon Ivy - Use cached JDTBeanIntrospector 
  *******************************************************************************/
 package org.eclipse.jst.jsf.validation.internal.appconfig;
 
@@ -54,11 +55,13 @@
         _typeCache = new HashMap<String, IType>();
     }
 
+    @Override
     protected EObjectValidationVisitor[] getChildNodeValidators() 
     {
         return PropertyValidationVisitor.NO_CHILDREN;
     }
 
+    @Override
     protected void doValidate(EObject object, List messages, IFile file) 
     {
         final String parentClassType = getParentClassType(object);
@@ -144,7 +147,7 @@
 
 	private Map<String, JDTBeanProperty> getProperties(final IType type, final IProject project) 
 	{
-		final JDTBeanIntrospector introspector = new JDTBeanIntrospector(type);
+		final JDTBeanIntrospector introspector = JDTBeanIntrospector.forType(type);
 		return introspector.getProperties();
 	}
 	
diff --git a/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/TestIJavaTypeDescriptor2_ChangeStability.java b/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/TestIJavaTypeDescriptor2_ChangeStability.java
index a623456..a92f1a1 100644
--- a/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/TestIJavaTypeDescriptor2_ChangeStability.java
+++ b/jsf/tests/org.eclipse.jst.jsf.context.symbol.tests/src/org/eclipse/jst/jsf/context/symbol/tests/TestIJavaTypeDescriptor2_ChangeStability.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2001, 2007 Oracle Corporation and others.
+ * Copyright (c) 2001, 2021 Oracle Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -8,7 +8,8 @@
  * SPDX-License-Identifier: EPL-2.0
  * 
  * Contributors:
- *     Oracle Corporation - initial API and implementation
+ *     Oracle Corporation  - initial API and implementation
+ *     Reto Weiss/Axon Ivy - Cache resolved types
  *******************************************************************************/
 package org.eclipse.jst.jsf.context.symbol.tests;
 
@@ -20,6 +21,7 @@
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaModelException;
 import org.eclipse.jdt.core.Signature;
 import org.eclipse.jdt.core.dom.AST;
 import org.eclipse.jdt.core.dom.ASTParser;
@@ -29,7 +31,7 @@
 import org.eclipse.jdt.core.dom.TypeDeclaration;
 import org.eclipse.jface.text.Document;
 import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
-import org.eclipse.jst.jsf.common.util.TypeUtil;
+import org.eclipse.jst.jsf.common.util.JDTTypeResolver;
 import org.eclipse.jst.jsf.context.symbol.IBeanInstanceSymbol;
 import org.eclipse.jst.jsf.context.symbol.IBeanMethodSymbol;
 import org.eclipse.jst.jsf.context.symbol.IJavaTypeDescriptor2;
@@ -52,6 +54,7 @@
  */
 public class TestIJavaTypeDescriptor2_ChangeStability extends ModelBaseTestCase 
 {
+    private static final IType[] EMPTY_SUPER_TYPES = new IType[0];
     private IBeanInstanceSymbol     _testBean1Symbol;
     private IBeanInstanceSymbol     _testBean2Symbol;
 
@@ -64,6 +67,7 @@
     private final static String testBeanName1 = "TestBean1";
     private final static String testBeanName2 = "TestBean2";
 
+    @Override
     protected void setUp() throws Exception 
     {
         super.setUp();
@@ -111,6 +115,7 @@
         return bean;
     }
     
+    @Override
     protected void tearDown() throws Exception 
     {
         super.tearDown();
@@ -129,7 +134,7 @@
         IType type = _testBean1Symbol.getJavaTypeDescriptor().getType();
         IMethod newMethod = type.createMethod(NON_BEAN_METHOD_CONTENTS, null, true, null);
         assertNotNull(newMethod);
-        assertEquals(NON_BEAN_METHOD_SIG, TypeUtil.resolveMethodSignature(type, newMethod.getSignature()));
+        assertEquals(NON_BEAN_METHOD_SIG, resolveMethodSignature(type, newMethod));
         assertTrue(newMethod.exists());
         
         // post-cond: bean has new method 
@@ -184,7 +189,7 @@
         IMethod newMethod = type.createMethod(BEAN_METHOD_CONTENTS, null, true, null);
         assertNotNull(newMethod);
         assertTrue(newMethod.exists());
-        assertEquals(BEAN_METHOD_SIG, TypeUtil.resolveMethodSignature(type, newMethod.getSignature()));
+        assertEquals(BEAN_METHOD_SIG, resolveMethodSignature(type, newMethod));
         
         {
             // post-cond: bean has new method 
@@ -218,7 +223,7 @@
         IType type = _testBean1Symbol.getJavaTypeDescriptor().getType();
         IMethod method = type.getMethod(EXISTING_BEAN_METHOD, new String[0]);
         assertNotNull(method);
-        assertEquals(EXISTING_BEAN_METHOD_SIG, TypeUtil.resolveMethodSignature(type, method.getSignature()));
+        assertEquals(EXISTING_BEAN_METHOD_SIG, resolveMethodSignature(type, method));
         assertTrue(method.exists());
         method.delete(true, null);
         assertFalse(method.exists());
@@ -253,7 +258,7 @@
         IType type = _testBean1Symbol.getJavaTypeDescriptor().getType();
         IMethod method = type.getMethod(EXISTING_BEAN_METHOD, new String[0]);
         assertNotNull(method);
-        assertEquals(EXISTING_BEAN_METHOD_SIG, TypeUtil.resolveMethodSignature(type, method.getSignature()));
+        assertEquals(EXISTING_BEAN_METHOD_SIG, resolveMethodSignature(type, method));
         assertTrue(method.exists());
         method.rename(NEW_READONLY_BEAN_METHOD_NAME, false, null);
         method = type.getMethod(NEW_READONLY_BEAN_METHOD_NAME, new String[0]);
@@ -283,7 +288,7 @@
         _beanProperties.put(prop.getName(), prop);
         compareSymbolMaps(_beanProperties, newProperties);
     }
-    
+
     private static final String  READONLY_BEAN_REPLACEMENT_METHOD =
         "public Integer "+EXISTING_BEAN_METHOD+"(){return new Integer(4);}";
     private static final String  READONLY_BEAN_REPLACEMENT_SIG =
@@ -518,4 +523,10 @@
         cu.getBuffer().setContents(newSource);
         cu.commitWorkingCopy(true, null);
     }
+    
+    private String resolveMethodSignature(IType type, IMethod method) throws JavaModelException
+    {
+      return new JDTTypeResolver(type, EMPTY_SUPER_TYPES).resolveMethodEraseTypeParams(method.getSignature());
+    }
+
 }
diff --git a/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanIntrospector.java b/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanIntrospector.java
index 69259f1..d878784 100644
--- a/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanIntrospector.java
+++ b/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanIntrospector.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2006, 2009 Oracle Corporation.
+ * Copyright (c) 2006, 2021 Oracle Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -9,6 +9,7 @@
  *
  * Contributors:
  *    Cameron Bateman/Oracle - initial API and implementation
+*     Reto Weiss/Axon Ivy    - Cache resolved types 
  * 
  ********************************************************************************/
 
@@ -16,8 +17,6 @@
 
 import java.util.Map;
 
-import junit.framework.TestCase;
-
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.jdt.core.IType;
@@ -25,13 +24,14 @@
 import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
 import org.eclipse.jst.jsf.common.util.JDTBeanIntrospector;
 import org.eclipse.jst.jsf.common.util.JDTBeanProperty;
-import org.eclipse.jst.jsf.common.util.JDTBeanPropertyWorkingCopy;
 import org.eclipse.jst.jsf.core.tests.TestsPlugin;
 import org.eclipse.jst.jsf.test.util.JDTTestEnvironment;
 import org.eclipse.jst.jsf.test.util.JSFTestUtil;
 import org.eclipse.jst.jsf.test.util.TestFileResource;
 import org.eclipse.jst.jsf.test.util.WebProjectTestEnvironment;
 
+import junit.framework.TestCase;
+
 /**
  * Tester fot he JDTBeanIntrospector class
  * 
@@ -144,17 +144,16 @@
         
         // introspect after classes loaded to ensure all dependencies
         // are in the project
-        JDTBeanIntrospector beanIntrospector =
-            new JDTBeanIntrospector(_testBean1Type);
+        JDTBeanIntrospector beanIntrospector = JDTBeanIntrospector.forType(_testBean1Type);
         _properties = beanIntrospector.getProperties();
 
-        beanIntrospector = new JDTBeanIntrospector(_testBeanSubclassType);
+        beanIntrospector = JDTBeanIntrospector.forType(_testBeanSubclassType);
         _subClassProperties = beanIntrospector.getProperties();
 
-        beanIntrospector = new JDTBeanIntrospector(_testBeanGenericType);
+        beanIntrospector = JDTBeanIntrospector.forType(_testBeanGenericType);
         _genericTypeProperties = beanIntrospector.getProperties();
 
-        beanIntrospector = new JDTBeanIntrospector(_testInterface);
+        beanIntrospector = JDTBeanIntrospector.forType(_testInterface);
         _interfaceProperties = beanIntrospector.getProperties();
     }
 
@@ -197,13 +196,6 @@
                 .size());
         assertNull("Empty string is invalid property name", properties.get(""));
         assertNull("Null is not a valid property name", properties.get(null));
-
-        // ensure type correctness of all values
-        for (final JDTBeanProperty value : properties.values())
-        {
-            // no working copies should slip their way in
-            assertFalse(value instanceof JDTBeanPropertyWorkingCopy);
-        }
     }
 
     /**
@@ -622,9 +614,7 @@
     {
         final JDTBeanProperty property =
             _genericTypeProperties.get("listOfListOfStrings");
-        assertEquals("Ljava.util.List;", property.getTypeSignature(true));
-        assertEquals("Ljava.util.List<Ljava.util.List<Ljava.lang.String;>;>;",
-                property.getTypeSignature(false));
+        assertEquals("Ljava.util.List;", property.getTypeSignature());
 
         assertEquals(1, property.getTypeParameterSignatures().size());
         assertEquals("Ljava.util.List<Ljava.lang.String;>;", property
@@ -635,9 +625,7 @@
     {
         final JDTBeanProperty property =
             _genericTypeProperties.get("mapOfString_String");
-        assertEquals("Ljava.util.Map;", property.getTypeSignature(true));
-        assertEquals("Ljava.util.Map<Ljava.lang.String;Ljava.lang.String;>;",
-                property.getTypeSignature(false));
+        assertEquals("Ljava.util.Map;", property.getTypeSignature());
 
         assertEquals(2, property.getTypeParameterSignatures().size());
         assertEquals("Ljava.lang.String;", property
@@ -650,9 +638,7 @@
     public void testUnboundedProperty_List() throws Exception
     {
         final JDTBeanProperty property = _genericTypeProperties.get("unboundedList");
-        assertEquals("Ljava.util.List;", property.getTypeSignature(true));
-        assertEquals("Ljava.util.List<Ljava.lang.Object;>;", property
-                .getTypeSignature(false));
+        assertEquals("Ljava.util.List;", property.getTypeSignature());
 
         assertEquals(1, property.getTypeParameterSignatures().size());
         assertEquals("Ljava.lang.Object;", property
diff --git a/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanPropertyWorkingCopy.java b/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanPropertyWorkingCopy.java
index 522e0f2..4562267 100644
--- a/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanPropertyWorkingCopy.java
+++ b/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestJDTBeanPropertyWorkingCopy.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2006, 2008 Oracle Corporation.
+ * Copyright (c) 2006, 2021 Oracle Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -9,12 +9,11 @@
  *
  * Contributors:
  *    Cameron Bateman/Oracle - initial API and implementation
+ *    Reto Weiss/Axon Ivy    - Cache resolved types *    
  * 
  ********************************************************************************/
 package org.eclipse.jst.jsf.core.tests.util;
 
-import junit.framework.TestCase;
-
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.jdt.core.IMethod;
@@ -22,12 +21,15 @@
 import org.eclipse.jdt.core.Signature;
 import org.eclipse.jst.jsf.common.util.JDTBeanProperty;
 import org.eclipse.jst.jsf.common.util.JDTBeanPropertyWorkingCopy;
+import org.eclipse.jst.jsf.common.util.JDTTypeResolver;
 import org.eclipse.jst.jsf.core.tests.TestsPlugin;
 import org.eclipse.jst.jsf.test.util.JDTTestEnvironment;
 import org.eclipse.jst.jsf.test.util.JSFTestUtil;
 import org.eclipse.jst.jsf.test.util.TestFileResource;
 import org.eclipse.jst.jsf.test.util.WebProjectTestEnvironment;
 
+import junit.framework.TestCase;
+
 /**
  * Tests basic operations on the jdt bean property
  * 
@@ -95,8 +97,7 @@
      */
     public void testSimpleBeanProperty()
     {
-        final JDTBeanPropertyWorkingCopy workingCopy =
-            new JDTBeanPropertyWorkingCopy(_testBean1Type);
+        final JDTBeanPropertyWorkingCopy workingCopy = createPropertyWorkingCopy();
 
         final IMethod simpleGetter =
             _testBean1Type.getMethod("getStringProp1", new String[0]);
@@ -132,8 +133,7 @@
      */
     public void testSimpleIsBeanProperty()
     {
-        final JDTBeanPropertyWorkingCopy workingCopy =
-            new JDTBeanPropertyWorkingCopy(_testBean1Type);
+        final JDTBeanPropertyWorkingCopy workingCopy = createPropertyWorkingCopy();
 
         final IMethod simpleGetter =
             _testBean1Type.getMethod("isBooleanIsProp1", new String[0]);
@@ -171,8 +171,7 @@
      */
     public void testIsAccessorTakesPrecedence()
     {
-        final JDTBeanPropertyWorkingCopy workingCopy =
-            new JDTBeanPropertyWorkingCopy(_testBean1Type);
+        final JDTBeanPropertyWorkingCopy workingCopy = createPropertyWorkingCopy();
 
         final IMethod simpleIsGetter =
             _testBean1Type.getMethod("isBooleanIsProp2", new String[0]);
@@ -254,8 +253,7 @@
      */
     public void testDoNotUseSetterIfDoesNotMatchGetterType()
     {
-        final JDTBeanPropertyWorkingCopy workingCopy =
-            new JDTBeanPropertyWorkingCopy(_testBean1Type);
+        final JDTBeanPropertyWorkingCopy workingCopy = createPropertyWorkingCopy();
 
         final IMethod simpleGetter =
             _testBean1Type.getMethod("getStringProperty2", new String[0]);
@@ -295,8 +293,7 @@
     public void testReadonlyBeanProperty()
     {
         // readonly get
-        JDTBeanPropertyWorkingCopy workingCopy =
-            new JDTBeanPropertyWorkingCopy(_testBean1Type);
+        JDTBeanPropertyWorkingCopy workingCopy = createPropertyWorkingCopy();
 
         final IMethod simpleGetter =
             _testBean1Type.getMethod("getReadonlyStringProperty",
@@ -326,7 +323,7 @@
         // should be an IType for a String
         assertNotNull(beanProperty.getType());
 
-        workingCopy = new JDTBeanPropertyWorkingCopy(_testBean1Type);
+        workingCopy = createPropertyWorkingCopy();
 
         // readonly is getter
         final IMethod isGetter =
@@ -365,8 +362,7 @@
     public void testWriteonlyBeanProperty()
     {
         // readonly get
-        final JDTBeanPropertyWorkingCopy workingCopy =
-            new JDTBeanPropertyWorkingCopy(_testBean1Type);
+        final JDTBeanPropertyWorkingCopy workingCopy = createPropertyWorkingCopy();
 
         final IMethod simpleSetter =
             _testBean1Type.getMethod("setWriteonlyStringProperty",
@@ -403,8 +399,7 @@
     public void testStringArrayProperty()
     {
         // readonly get
-        final JDTBeanPropertyWorkingCopy workingCopy =
-            new JDTBeanPropertyWorkingCopy(_testBean1Type);
+        final JDTBeanPropertyWorkingCopy workingCopy = createPropertyWorkingCopy();
 
         final IMethod simpleGetter =
             _testBean1Type.getMethod("getStringArrayProperty",
@@ -444,8 +439,7 @@
     public void testCollectionProperty()
     {
         // readonly get
-        final JDTBeanPropertyWorkingCopy workingCopy =
-            new JDTBeanPropertyWorkingCopy(_testBean1Type);
+        final JDTBeanPropertyWorkingCopy workingCopy = createPropertyWorkingCopy();
 
         final IMethod simpleGetter =
             _testBean1Type
@@ -485,8 +479,7 @@
     public void testMapProperty()
     {
         // readonly get
-        final JDTBeanPropertyWorkingCopy workingCopy =
-            new JDTBeanPropertyWorkingCopy(_testBean1Type);
+        final JDTBeanPropertyWorkingCopy workingCopy = createPropertyWorkingCopy();
 
         final IMethod simpleGetter =
             _testBean1Type.getMethod("getMapProperty", new String[0]);
@@ -518,4 +511,9 @@
         assertNotNull(beanProperty.getType());
     }
 
+    private JDTBeanPropertyWorkingCopy createPropertyWorkingCopy()
+    {
+      return new JDTBeanPropertyWorkingCopy(_testBean1Type, new JDTTypeResolver(_testBean1Type, new IType[0]), "StringProp1");
+    }
+
 }
diff --git a/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestTypeUtil.java b/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestTypeUtil.java
index 62036e7..6f90630 100644
--- a/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestTypeUtil.java
+++ b/jsf/tests/org.eclipse.jst.jsf.core.tests/src/org/eclipse/jst/jsf/core/tests/util/TestTypeUtil.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2008 Oracle Corporation.
+ * Copyright (c) 2007, 2021 Oracle Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -9,6 +9,7 @@
  *
  * Contributors:
  *    Cameron Bateman/Oracle - initial API and implementation
+ *    Reto Weiss/Axon Ivy    - Cache resolved types    
  * 
  ********************************************************************************/
 package org.eclipse.jst.jsf.core.tests.util;
@@ -16,12 +17,11 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import junit.framework.TestCase;
-
 import org.eclipse.jdt.core.IClasspathEntry;
 import org.eclipse.jdt.core.IMethod;
 import org.eclipse.jdt.core.IType;
 import org.eclipse.jst.jsf.common.internal.types.TypeConstants;
+import org.eclipse.jst.jsf.common.util.JDTTypeResolver;
 import org.eclipse.jst.jsf.common.util.TypeUtil;
 import org.eclipse.jst.jsf.core.tests.TestsPlugin;
 import org.eclipse.jst.jsf.test.util.JDTTestEnvironment;
@@ -29,8 +29,12 @@
 import org.eclipse.jst.jsf.test.util.TestFileResource;
 import org.eclipse.jst.jsf.test.util.WebProjectTestEnvironment;
 
+import junit.framework.TestCase;
+
 public class TestTypeUtil extends TestCase
 {
+  private static final IType[] EMPTY_SUPER_TYPES = new IType[0];
+  
     private JDTTestEnvironment  _jdtTestEnvironment;
     private IType               _testBean1Type;
     private IType               _testBeanSubclassType;
@@ -52,6 +56,7 @@
 
     // private final static String testEnumName2 = "TestEnum2";
 
+    @Override
     protected void setUp() throws Exception
     {
         super.setUp();
@@ -153,6 +158,7 @@
         // new JDTBeanIntrospector(_testBeanGenericType);
     }
 
+    @Override
     protected void tearDown() throws Exception
     {
         super.tearDown();
@@ -169,28 +175,28 @@
     public void testResolveTypeSignatureITypeString()
     {
         // this one should be the same regardless of type erasure
-        assertEquals(TypeConstants.TYPE_STRING, TypeUtil.resolveTypeSignature(
-                _testBean1Type, "QString;", true));
-        assertEquals(TypeConstants.TYPE_STRING, TypeUtil.resolveTypeSignature(
-                _testBean1Type, "QString;", false));
+        assertEquals(TypeConstants.TYPE_STRING, 
+                resolver(_testBean1Type).resolveEraseTypeParams("QString;"));
+        assertEquals(TypeConstants.TYPE_STRING, 
+                resolver(_testBean1Type).resolveKeepTypeParams("QString;"));
 
         // no parameters are provided here, so we should see the same result
-        assertEquals(TypeConstants.TYPE_COLLECTION, TypeUtil
-                .resolveTypeSignature(_testBean1Type, "QCollection;", true));
-        assertEquals(TypeConstants.TYPE_COLLECTION, TypeUtil
-                .resolveTypeSignature(_testBean1Type, "QCollection;", false));
-        assertEquals(TypeConstants.TYPE_MAP, TypeUtil.resolveTypeSignature(
-                _testBean1Type, "QMap;", true));
-        assertEquals(TypeConstants.TYPE_MAP, TypeUtil.resolveTypeSignature(
-                _testBean1Type, "QMap;", false));
+        assertEquals(TypeConstants.TYPE_COLLECTION, 
+                resolver(_testBean1Type).resolveEraseTypeParams("QCollection;"));
+        assertEquals(TypeConstants.TYPE_COLLECTION, 
+                resolver(_testBean1Type).resolveKeepTypeParams("QCollection;"));
+        assertEquals(TypeConstants.TYPE_MAP, 
+                resolver(_testBean1Type).resolveEraseTypeParams("QMap;"));
+        assertEquals(TypeConstants.TYPE_MAP, 
+                resolver(_testBean1Type).resolveKeepTypeParams("QMap;"));
 
         // in this case, the provided signature has type erasure, so the answer
         // will different depending on typeErasure flag
-        final String typeSigWithErasure = TypeUtil.resolveTypeSignature(
-                _testBean1Type, "QMap<QString;QString;>;", true);
+        final String typeSigWithErasure = resolver(_testBean1Type)
+                .resolveEraseTypeParams("QMap<QString;QString;>;");
         assertEquals(TypeConstants.TYPE_MAP, typeSigWithErasure);
-        final String typeSigNoErasure = TypeUtil.resolveTypeSignature(
-                _testBean1Type, "QMap<QString;QString;>;", false);
+        final String typeSigNoErasure = resolver(_testBean1Type)
+                .resolveKeepTypeParams("QMap<QString;QString;>;");
         assertEquals("Ljava.util.Map<Ljava.lang.String;Ljava.lang.String;>;",
                 typeSigNoErasure);
 
@@ -198,28 +204,28 @@
         final IType mapType = TypeUtil.resolveType(_jdtTestEnvironment
                 .getJavaProject(), "Ljava.util.Map;");
         assertNotNull(mapType);
-        assertEquals(TypeConstants.TYPE_JAVAOBJECT, TypeUtil
-                .resolveTypeSignature(mapType, "TV;", false));
+        assertEquals(TypeConstants.TYPE_JAVAOBJECT, 
+                resolver(mapType).resolveKeepTypeParams("TV;"));
 
         // unfound signature
-        assertEquals("QSomeNotRealClass;", TypeUtil.resolveTypeSignature(
-                _testBean1Type, "QSomeNotRealClass;", false));
+        assertEquals("QSomeNotRealClass;", 
+                resolver(_testBean1Type).resolveKeepTypeParams("QSomeNotRealClass;"));
 
         // arrays
-        assertEquals("[I", TypeUtil.resolveTypeSignature(_testBean1Type, "[I"));
+        assertEquals("[I", resolver(_testBean1Type).resolveEraseTypeParams("[I"));
 
-        assertEquals("[Ljava.lang.String;", TypeUtil.resolveTypeSignature(
-                _testBean1Type, "[QString;"));
+        assertEquals("[Ljava.lang.String;", 
+                resolver(_testBean1Type).resolveKeepTypeParams("[QString;"));
 
-        assertEquals("[Ljava.util.Map;", TypeUtil.resolveTypeSignature(
-                _testBean1Type, "[QMap;"));
+        assertEquals("[Ljava.util.Map;", 
+                resolver(_testBean1Type).resolveKeepTypeParams("[QMap;"));
 
-        assertEquals("[Ljava.util.Collection;", TypeUtil.resolveTypeSignature(
-                _testBean1Type, "[QCollection;"));
+        assertEquals("[Ljava.util.Collection;", 
+                resolver(_testBean1Type).resolveKeepTypeParams("[QCollection;"));
 
         // array of arrays
-        assertEquals("[[[Ljava.lang.String;", TypeUtil.resolveTypeSignature(
-                _testBean1Type, "[[[QString;"));
+        assertEquals("[[[Ljava.lang.String;", 
+                resolver(_testBean1Type).resolveKeepTypeParams("[[[QString;"));
 
         // cover cases where wildcards and/or capture are used. All should be
         // equivalent to the case for
@@ -235,50 +241,50 @@
             final boolean typeErasure)
     {
         // extends
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+        assertEquals(expected, resolveTypeSignature(_testBean1Type,
                 "QMap<+QString;+QString;>;", typeErasure));
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+        assertEquals(expected, resolveTypeSignature(_testBean1Type,
                 "QMap<+QString;QString;>;", typeErasure));
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+        assertEquals(expected, resolveTypeSignature(_testBean1Type,
                 "QMap<QString;+QString;>;", typeErasure));
         // super
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+        assertEquals(expected, resolveTypeSignature(_testBean1Type,
                 "QMap<-QString;-QString;>;", typeErasure));
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+        assertEquals(expected, resolveTypeSignature(_testBean1Type,
                 "QMap<-QString;QString;>;", typeErasure));
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+        assertEquals(expected, resolveTypeSignature(_testBean1Type,
                 "QMap<QString;-QString;>;", typeErasure));
         // star
         // this one is distinct because * are converted to Object
         final String expected1 = "Ljava.util.Map"
                 + (typeErasure ? ";"
                         : "<Ljava.lang.Object;Ljava.lang.Object;>;");
-        assertEquals(expected1, TypeUtil.resolveTypeSignature(_testBean1Type,
+        assertEquals(expected1, resolveTypeSignature(_testBean1Type,
                 "QMap<**>;", typeErasure));
         final String expected2 = "Ljava.util.Map"
                 + (typeErasure ? ";"
                         : "<Ljava.lang.Object;Ljava.lang.String;>;");
-        assertEquals(expected2, TypeUtil.resolveTypeSignature(_testBean1Type,
+        assertEquals(expected2, resolveTypeSignature(_testBean1Type,
                 "QMap<*QString;>;", typeErasure));
         final String expected3 = "Ljava.util.Map"
                 + (typeErasure ? ";"
                         : "<Ljava.lang.String;Ljava.lang.Object;>;");
-        assertEquals(expected3, TypeUtil.resolveTypeSignature(_testBean1Type,
+        assertEquals(expected3, resolveTypeSignature(_testBean1Type,
                 "QMap<QString;*>;", typeErasure));
         // capture extends
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+        assertEquals(expected, resolveTypeSignature(_testBean1Type,
                 "QMap<!+QString;!+QString;>;", typeErasure));
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+        assertEquals(expected, resolveTypeSignature(_testBean1Type,
                 "QMap<!+QString;QString;>;", typeErasure));
-        assertEquals(expected, TypeUtil.resolveTypeSignature(_testBean1Type,
+        assertEquals(expected, resolveTypeSignature(_testBean1Type,
                 "QMap<QString;!+QString;>;", typeErasure));
 
-        assertEquals("Ljava.lang.String;", TypeUtil.resolveTypeSignature(
+        assertEquals("Ljava.lang.String;", resolveTypeSignature(
                 _testBean1Type, "!+QString;", typeErasure));
 
         // test regression on
         // https://bugs.eclipse.org/bugs/show_bug.cgi?id=197506
-        assertEquals("Ljava.lang.Object;", TypeUtil.resolveTypeSignature(
+        assertEquals("Ljava.lang.Object;", resolveTypeSignature(
                 _testBean1Type, "*", typeErasure));
     }
 
@@ -322,21 +328,21 @@
 
     public void testResolveMethodSignature() throws Exception
     {
-        assertEquals("()Ljava.lang.String;", TypeUtil.resolveMethodSignature(
-                _testBean1Type, "()QString;"));
-        assertEquals("(Ljava.lang.String;)V", TypeUtil.resolveMethodSignature(
-                _testBean1Type, "(QString;)V"));
-        assertEquals("(Ljava.lang.String;Z)V", TypeUtil.resolveMethodSignature(
-                _testBean1Type, "(QString;Z)V"));
+        assertEquals("()Ljava.lang.String;", 
+                resolver(_testBean1Type).resolveMethodEraseTypeParams("()QString;"));
+        assertEquals("(Ljava.lang.String;)V", 
+                resolver(_testBean1Type).resolveMethodEraseTypeParams("(QString;)V"));
+        assertEquals("(Ljava.lang.String;Z)V", 
+                resolver(_testBean1Type).resolveMethodEraseTypeParams("(QString;Z)V"));
 
         IMethod method = _testBean1Type.getMethod("getStringProp1", null);
-        assertEquals("()Ljava.lang.String;", TypeUtil.resolveMethodSignature(
-                _testBean1Type, method.getSignature()));
+        assertEquals("()Ljava.lang.String;", 
+                resolver(_testBean1Type).resolveMethodEraseTypeParams(method.getSignature()));
 
         method = _testBean1Type.getMethod("setStringProperty2", new String[]
         { "I" });
-        assertEquals("(I)V", TypeUtil.resolveMethodSignature(_testBean1Type,
-                method.getSignature()));
+        assertEquals("(I)V", 
+                resolver(_testBean1Type).resolveMethodEraseTypeParams(method.getSignature()));
 
         // test binary methods
         // the framework returns method signatures using "/" instead of "."
@@ -345,38 +351,36 @@
         // sanity: _binaryType must a JDT BinaryType impl for this test to
         // be valid
         assertTrue(_binaryType.isBinary());
-        assertEquals("()Ljava.lang.String;", TypeUtil.resolveMethodSignature(
-                _binaryType, _binaryType.getMethod("getStringProperty", null)
+        assertEquals("()Ljava.lang.String;", resolver(_testBean1Type).resolveMethodEraseTypeParams(
+                _binaryType.getMethod("getStringProperty", null)
                         .getSignature()));
 
-        assertEquals("(Ljava.lang.String;)V", TypeUtil.resolveMethodSignature(
-                _binaryType, _binaryType.getMethod("setStringProperty",
+        assertEquals("(Ljava.lang.String;)V", resolver(_testBean1Type).resolveMethodEraseTypeParams(
+                _binaryType.getMethod("setStringProperty",
                         new String[]
                         { "Ljava.lang.String;" }).getSignature()));
 
-        assertEquals("()I", TypeUtil.resolveMethodSignature(_binaryType,
+        assertEquals("()I", resolver(_testBean1Type).resolveMethodEraseTypeParams(
                 _binaryType.getMethod("getIntegerProperty", null)
                         .getSignature()));
 
-        assertEquals("(I)V", TypeUtil.resolveMethodSignature(_binaryType,
+        assertEquals("(I)V", resolver(_testBean1Type).resolveMethodEraseTypeParams(
                 _binaryType.getMethod("setIntegerProperty", new String[]
                 { "I" }).getSignature()));
 
-        assertEquals("()Lcom.test.BinaryPropertyAndMethodType;", TypeUtil
-                .resolveMethodSignature(_binaryType, _binaryType.getMethod(
+        assertEquals("()Lcom.test.BinaryPropertyAndMethodType;", 
+                resolver(_testBean1Type).resolveMethodEraseTypeParams(_binaryType.getMethod(
                         "getUserDefined", null).getSignature()));
 
-        assertEquals("(Lcom.test.BinaryPropertyAndMethodType;)V", TypeUtil
-                .resolveMethodSignature(_binaryType, _binaryType.getMethod(
+        assertEquals("(Lcom.test.BinaryPropertyAndMethodType;)V", 
+                resolver(_testBean1Type).resolveMethodEraseTypeParams(_binaryType.getMethod(
                         "setUserDefined", new String[]
                         { "Lcom.test.BinaryPropertyAndMethodType;" })
                         .getSignature()));
 
         assertEquals(
                 "(Ljava.lang.String;Lcom.test.BinaryPropertyAndMethodType;I)I",
-                TypeUtil
-                        .resolveMethodSignature(
-                                _binaryType,
+                resolver(_testBean1Type).resolveMethodEraseTypeParams(
                                 _binaryType
                                         .getMethod(
                                                 "methodWithMultipleArgs",
@@ -443,4 +447,21 @@
         assertTrue(TypeUtil.isEnumMember(type, "deadbeef"));
 
     }
+        
+    String resolveTypeSignature(IType type, String typeSignature, boolean erased)
+    {
+      if (erased)
+      {
+        return new JDTTypeResolver(type, EMPTY_SUPER_TYPES).resolveEraseTypeParams(typeSignature);
+      }
+      else
+      {
+        return new JDTTypeResolver(type, EMPTY_SUPER_TYPES).resolveKeepTypeParams(typeSignature);
+      }
+    }
+    
+    JDTTypeResolver resolver(IType type)
+    {
+      return new JDTTypeResolver(type, EMPTY_SUPER_TYPES);
+    }
 }
diff --git a/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/TestDefaultPropertyResolver.java b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/TestDefaultPropertyResolver.java
index cdf0161..bb811d1 100644
--- a/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/TestDefaultPropertyResolver.java
+++ b/jsf/tests/org.eclipse.jst.jsf.designtime.tests/src/org/eclipse/jst/jsf/designtime/tests/TestDefaultPropertyResolver.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2011 Oracle Corporation.
+ * Copyright (c) 2007, 2021 Oracle Corporation.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
@@ -9,6 +9,7 @@
  *
  * Contributors:
  *    Cameron Bateman/Oracle - initial API and implementation
+ *    Reto Weiss/Axon Ivy    - Cache JDTBeanIntrospector
  * 
  ********************************************************************************/
 package org.eclipse.jst.jsf.designtime.tests;
@@ -17,8 +18,6 @@
 import java.util.HashMap;
 import java.util.Map;
 
-import junit.framework.TestCase;
-
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.jdt.core.IType;
@@ -44,6 +43,8 @@
 import org.eclipse.jst.jsf.test.util.TestFileResource;
 import org.eclipse.jst.jsf.test.util.WebProjectTestEnvironment;
 
+import junit.framework.TestCase;
+
 /**
  * Unit tests for the default property resolver
  * 
@@ -199,44 +200,43 @@
      */
     public void testSanity()
     {
-        JDTBeanIntrospector beanIntrospector =
-            new JDTBeanIntrospector(_testBean1Type);
+        JDTBeanIntrospector beanIntrospector = JDTBeanIntrospector.forType(_testBean1Type);
         Map<String, JDTBeanProperty> props = beanIntrospector.getProperties();
         assertEquals(NUM_PROPERTIES_TEST_BEAN_1, props.size());
         assertTrue(props.containsKey("stringProp1"));
         assertTrue(props.containsKey("booleanIsProp1"));
 
-        beanIntrospector = new JDTBeanIntrospector(_testMapBean1Type);
+        beanIntrospector = JDTBeanIntrospector.forType(_testMapBean1Type);
         props = beanIntrospector.getProperties();
         // has 2 as a bean: isEmpty -> empty property + class
         assertEquals(2, props.size());
 
-        beanIntrospector = new JDTBeanIntrospector(_testBean2Type);
+        beanIntrospector = JDTBeanIntrospector.forType(_testBean2Type);
         props = beanIntrospector.getProperties();
         // two props: myBean3, class
         assertEquals(2, props.size());
 
-        beanIntrospector = new JDTBeanIntrospector(_testBean3Type);
+        beanIntrospector = JDTBeanIntrospector.forType(_testBean3Type);
         props = beanIntrospector.getProperties();
         // two props: one of type TestBean2 + class
         assertEquals(2, props.size());
 
-        beanIntrospector = new JDTBeanIntrospector(_testBeanWithMapProp);
+        beanIntrospector = JDTBeanIntrospector.forType(_testBeanWithMapProp);
         props = beanIntrospector.getProperties();
         // two props: one of type Map + class
         assertEquals(2, props.size());
 
-        beanIntrospector = new JDTBeanIntrospector(_testListBeanType);
+        beanIntrospector = JDTBeanIntrospector.forType(_testListBeanType);
         props = beanIntrospector.getProperties();
         // includes isEmpty and class
         assertEquals(3, props.size());
 
-        beanIntrospector = new JDTBeanIntrospector(_testBeanWithListPropType);
+        beanIntrospector = JDTBeanIntrospector.forType(_testBeanWithListPropType);
         props = beanIntrospector.getProperties();
         assertEquals(2, props.size());
 
         beanIntrospector =
-            new JDTBeanIntrospector(_testBeanWithGenericProperties);
+            JDTBeanIntrospector.forType(_testBeanWithGenericProperties);
         props = beanIntrospector.getProperties();
         assertEquals(3, props.size());
     }