How to use

TypeCache$CachedType

in

com.buschmais.jqassistant.plugin.java.api.scanner

@Override
public void visitLocalVariable(final String name, final String desc, final String signature, final Label start, final Label end, final int index) {
  if (visitorHelper.getClassModelConfiguration().isMethodDeclaresVariable() && !THIS.equals(name)) {
    final VariableDescriptor variableDescriptor = visitorHelper.getVariableDescriptor(name, SignatureHelper.getFieldSignature(name, desc));
    if (signature == null) {
      TypeDescriptor type = visitorHelper.resolveType(SignatureHelper.getType((desc)), containingType).getTypeDescriptor();
      variableDescriptor.setType(type);
    } else {
      new SignatureReader(signature).accept(new AbstractTypeSignatureVisitor(containingType, visitorHelper) {
        @Override
        public SignatureVisitor visitArrayType() {
          return dependentTypeSignatureVisitor;
        }
        @Override
        public SignatureVisitor visitTypeArgument(char wildcard) {
          return dependentTypeSignatureVisitor;
        }
        @Override
        public void visitEnd(TypeDescriptor resolvedTypeDescriptor) {
          variableDescriptor.setType(resolvedTypeDescriptor);
        }
      });
    }
    methodDescriptor.getVariables().add(variableDescriptor);
  }
}

/**
 * Return the method descriptor for the given type and method signature.
 *
 * @param cachedType
 *            The containing type.
 * @param signature
 *            The method signature.
 * @return The method descriptor.
 */
MethodDescriptor getMethodDescriptor(TypeCache.CachedType<?> cachedType, String signature) {
  MethodDescriptor methodDescriptor = cachedType.getMethod(signature);
  if (methodDescriptor == null) {
    if (signature.startsWith(CONSTRUCTOR_METHOD)) {
      methodDescriptor = scannerContext.getStore().create(ConstructorDescriptor.class);
    } else {
      methodDescriptor = scannerContext.getStore().create(MethodDescriptor.class);
    }
    methodDescriptor.setSignature(signature);
    cachedType.addMember(signature, methodDescriptor);
  }
  return methodDescriptor;
}

  public void storeDependencies(TypeCache.CachedType<?> cachedType) {
    Map<TypeDescriptor, Integer> dependencies = cachedType.getDependencies();
    for (Map.Entry<TypeDescriptor, Integer> entry : dependencies.entrySet()) {
      TypeDescriptor dependency = entry.getKey();
      final Integer weight = entry.getValue();
      TypeDescriptor dependent = cachedType.getTypeDescriptor();
      TypeDependsOnDescriptor dependsOnDescriptor = scannerContext.getStore().create(dependent, TypeDependsOnDescriptor.class, dependency);
      if (classModelConfiguration.isTypeDependsOnWeight()) {
        dependsOnDescriptor.setWeight(weight);
      }
    }
  }
}

if (servletClass != null) {
  TypeCache.CachedType<TypeDescriptor> servletClassType = context.peek(TypeResolver.class).resolve(servletClass.getValue(), context);
  servletDescriptor.setType(servletClassType.getTypeDescriptor());

if (servletClass != null) {
  TypeCache.CachedType<TypeDescriptor> servletClassType = context.peek(TypeResolver.class).resolve(servletClass.getValue(), context);
  servletDescriptor.setType(servletClassType.getTypeDescriptor());

TypeDescriptor typeDescriptor = scanner.getContext().peek(TypeResolver.class).resolve(clazz, scanner.getContext()).getTypeDescriptor();
persistenceUnitDescriptor.getContains().add(typeDescriptor);

setModifiers(access, fieldDescriptor);
if (signature == null) {
  TypeDescriptor type = visitorHelper.resolveType(SignatureHelper.getType((desc)), cachedType).getTypeDescriptor();
  fieldDescriptor.setType(type);
} else {

TypeResolver typeResolver = context.peek(TypeResolver.class);
TypeCache.CachedType<TypeDescriptor> filterClassDescriptor = typeResolver.resolve(filterClass.getValue(), context);
filterDescriptor.setType(filterClassDescriptor.getTypeDescriptor());

TypeResolver typeResolver = context.peek(TypeResolver.class);
TypeCache.CachedType<TypeDescriptor> filterClassDescriptor = typeResolver.resolve(filterClass.getValue(), context);
filterDescriptor.setType(filterClassDescriptor.getTypeDescriptor());

@Override
public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) {
  MethodDescriptor methodDescriptor = visitorHelper.getMethodDescriptor(cachedType, SignatureHelper.getMethodSignature(name, desc));
  methodDescriptor.setName(name);
  setModifiers(access, methodDescriptor);
  if (hasFlag(access, Opcodes.ACC_ABSTRACT)) {
    methodDescriptor.setAbstract(Boolean.TRUE);
  }
  if (hasFlag(access, Opcodes.ACC_NATIVE)) {
    methodDescriptor.setNative(Boolean.TRUE);
  }
  if (signature == null) {
    String returnType = SignatureHelper.getType(org.objectweb.asm.Type.getReturnType(desc));
    methodDescriptor.setReturns(visitorHelper.resolveType(returnType, cachedType).getTypeDescriptor());
    org.objectweb.asm.Type[] types = org.objectweb.asm.Type.getArgumentTypes(desc);
    for (int i = 0; i < types.length; i++) {
      String parameterType = SignatureHelper.getType(types[i]);
      TypeDescriptor typeDescriptor = visitorHelper.resolveType(parameterType, cachedType).getTypeDescriptor();
      ParameterDescriptor parameterDescriptor = visitorHelper.addParameterDescriptor(methodDescriptor, i);
      parameterDescriptor.setType(typeDescriptor);
    }
  } else {
    new SignatureReader(signature).accept(new MethodSignatureVisitor(cachedType, methodDescriptor, visitorHelper, dependentTypeSignatureVisitor));
  }
  for (int i = 0; exceptions != null && i < exceptions.length; i++) {
    TypeDescriptor exceptionType = visitorHelper.resolveType(SignatureHelper.getObjectType(exceptions[i]), cachedType).getTypeDescriptor();
    methodDescriptor.getDeclaredThrowables().add(exceptionType);
  }
  return new MethodVisitor(cachedType, methodDescriptor, visitorHelper, dependentTypeSignatureVisitor);
}

@Override
public void visit(final int version, final int access, final String name, final String signature, final String superName, final String[] interfaces) {
  Class<? extends ClassFileDescriptor> javaType = getJavaType(access);
  String fullQualifiedName = SignatureHelper.getObjectType(name);
  cachedType = visitorHelper.createType(fullQualifiedName, fileDescriptor, javaType);
  dependentTypeSignatureVisitor = new DependentTypeSignatureVisitor(cachedType, visitorHelper);
  ClassFileDescriptor classFileDescriptor = cachedType.getTypeDescriptor();
  classFileDescriptor.setByteCodeVersion(version);
  if (hasFlag(access, Opcodes.ACC_ABSTRACT) && !hasFlag(access, Opcodes.ACC_INTERFACE)) {
    classFileDescriptor.setAbstract(Boolean.TRUE);
  }
  setModifiers(access, classFileDescriptor);
  if (signature == null) {
    if (superName != null) {
      TypeDescriptor superClassType = visitorHelper.resolveType(SignatureHelper.getObjectType(superName), cachedType).getTypeDescriptor();
      classFileDescriptor.setSuperClass(superClassType);
    }
    for (int i = 0; interfaces != null && i < interfaces.length; i++) {
      TypeDescriptor interfaceType = visitorHelper.resolveType(SignatureHelper.getObjectType(interfaces[i]), cachedType).getTypeDescriptor();
      classFileDescriptor.getInterfaces().add(interfaceType);
    }
  } else {
    new SignatureReader(signature).accept(new ClassSignatureVisitor(cachedType, visitorHelper, dependentTypeSignatureVisitor));
  }
}

/**
 * Add an annotation descriptor of the given type name to an annotated
 * descriptor.
 *
 * @param annotatedDescriptor
 *            The annotated descriptor.
 * @param typeName
 *            The type name of the annotation.
 * @return The annotation descriptor.
 */
AnnotationValueDescriptor addAnnotation(TypeCache.CachedType containingDescriptor, AnnotatedDescriptor annotatedDescriptor, String typeName) {
  if (typeName != null) {
    TypeDescriptor type = resolveType(typeName, containingDescriptor).getTypeDescriptor();
    AnnotationValueDescriptor annotationDescriptor = scannerContext.getStore().create(AnnotationValueDescriptor.class);
    annotationDescriptor.setType(type);
    annotatedDescriptor.getAnnotatedBy().add(annotationDescriptor);
    return annotationDescriptor;
  }
  return null;
}

@Override
public BeansXmlDescriptor scan(FileResource item, BeansXmlDescriptor beansXmlDescriptor, String path, Scope scope, Scanner scanner) throws IOException {
  ScannerContext context = scanner.getContext();
  Beans beans = unmarshaller.unmarshal(item);
  beansXmlDescriptor.setVersion(beans.getVersion());
  beansXmlDescriptor.setBeanDiscoveryMode(beans.getBeanDiscoveryMode());
  for (Object o : beans.getInterceptorsOrDecoratorsOrAlternatives()) {
    if (o instanceof Interceptors) {
      addTypes(((Interceptors) o).getClazz(), beansXmlDescriptor.getInterceptors(), context);
    } else if (o instanceof Decorators) {
      addTypes(((Decorators) o).getClazz(), beansXmlDescriptor.getDecorators(), context);
    } else if (o instanceof Alternatives) {
      List<JAXBElement<String>> clazzOrStereotype = ((Alternatives) o).getClazzOrStereotype();
      for (JAXBElement<String> element : clazzOrStereotype) {
        TypeDescriptor alternative = scanner.getContext().peek(TypeResolver.class).resolve(element.getValue(), context).getTypeDescriptor();
        beansXmlDescriptor.getAlternatives().add(alternative);
      }
    }
  }
  return beansXmlDescriptor;
}

private ListenerDescriptor createListener(ListenerType listenerType, ScannerContext context) {
  Store store = context.getStore();
  ListenerDescriptor listenerDescriptor = store.create(ListenerDescriptor.class);
  for (DescriptionType descriptionType : listenerType.getDescription()) {
    listenerDescriptor.getDescriptions().add(XmlDescriptorHelper.createDescription(descriptionType, store));
  }
  for (DisplayNameType displayNameType : listenerType.getDisplayName()) {
    listenerDescriptor.getDisplayNames().add(XmlDescriptorHelper.createDisplayName(displayNameType, store));
  }
  for (IconType iconType : listenerType.getIcon()) {
    listenerDescriptor.getIcons().add(XmlDescriptorHelper.createIcon(iconType, store));
  }
  TypeResolver typeResolver = context.peek(TypeResolver.class);
  FullyQualifiedClassType listenerClass = listenerType.getListenerClass();
  TypeCache.CachedType<TypeDescriptor> listenerClassDescriptor = typeResolver.resolve(listenerClass.getValue(), context);
  listenerDescriptor.setType(listenerClassDescriptor.getTypeDescriptor());
  return listenerDescriptor;
}

private ListenerDescriptor createListener(ListenerType listenerType, ScannerContext context) {
  Store store = context.getStore();
  ListenerDescriptor listenerDescriptor = store.create(ListenerDescriptor.class);
  for (DescriptionType descriptionType : listenerType.getDescription()) {
    listenerDescriptor.getDescriptions().add(XmlDescriptorHelper.createDescription(descriptionType, store));
  }
  for (DisplayNameType displayNameType : listenerType.getDisplayName()) {
    listenerDescriptor.getDisplayNames().add(XmlDescriptorHelper.createDisplayName(displayNameType, store));
  }
  for (IconType iconType : listenerType.getIcon()) {
    listenerDescriptor.getIcons().add(XmlDescriptorHelper.createIcon(iconType, store));
  }
  TypeResolver typeResolver = context.peek(TypeResolver.class);
  FullyQualifiedClassType listenerClass = listenerType.getListenerClass();
  TypeCache.CachedType<TypeDescriptor> listenerClassDescriptor = typeResolver.resolve(listenerClass.getValue(), context);
  listenerDescriptor.setType(listenerClassDescriptor.getTypeDescriptor());
  return listenerDescriptor;
}

@Override
public org.objectweb.asm.AnnotationVisitor visitParameterAnnotation(final int parameter, final String desc, final boolean visible) {
  String annotationType = SignatureHelper.getType(desc);
  if (JAVA_LANG_SYNTHETIC.equals(annotationType)) {
    // Ignore synthetic parameters add the start of the signature, i.e.
    // determine the number of synthetic parameters
    syntheticParameters = Math.max(syntheticParameters, parameter + 1);
    return null;
  }
  ParameterDescriptor parameterDescriptor = visitorHelper.getParameterDescriptor(methodDescriptor, parameter - syntheticParameters);
  if (parameterDescriptor == null) {
    LOGGER.warn("Cannot find parameter with index " + (parameter - syntheticParameters) + " in method signature "
        + containingType.getTypeDescriptor().getFullQualifiedName() + "#" + methodDescriptor.getSignature());
    return null;
  }
  AnnotationValueDescriptor annotationDescriptor = visitorHelper.addAnnotation(containingType, parameterDescriptor, SignatureHelper.getType(desc));
  return new AnnotationVisitor(containingType, annotationDescriptor, visitorHelper);
}

/**
 * Return the field descriptor for the given type and field signature.
 *
 * @param cachedType
 *            The containing type.
 * @param signature
 *            The field signature.
 * @return The field descriptor.
 */
FieldDescriptor getFieldDescriptor(TypeCache.CachedType<?> cachedType, String signature) {
  FieldDescriptor fieldDescriptor = cachedType.getField(signature);
  if (fieldDescriptor == null) {
    fieldDescriptor = scannerContext.getStore().create(FieldDescriptor.class);
    fieldDescriptor.setSignature(signature);
    cachedType.addMember(signature, fieldDescriptor);
  }
  return fieldDescriptor;
}

private ErrorPageDescriptor createErrorPage(ErrorPageType errorPageType, ScannerContext context) {
  ErrorPageDescriptor errorPageDescriptor = context.getStore().create(ErrorPageDescriptor.class);
  ErrorCodeType errorCode = errorPageType.getErrorCode();
  if (errorCode != null) {
    errorPageDescriptor.setErrorCode(errorCode.getValue().intValue());
  }
  FullyQualifiedClassType exceptionType = errorPageType.getExceptionType();
  if (exceptionType != null) {
    TypeResolver typeResolver = context.peek(TypeResolver.class);
    TypeCache.CachedType<TypeDescriptor> cachedType = typeResolver.resolve(exceptionType.getValue(), context);
    errorPageDescriptor.setExceptionType(cachedType.getTypeDescriptor());
  }
  errorPageDescriptor.setErrorPage(errorPageType.getLocation().getValue());
  return errorPageDescriptor;
}

private ErrorPageDescriptor createErrorPage(ErrorPageType errorPageType, ScannerContext context) {
  ErrorPageDescriptor errorPageDescriptor = context.getStore().create(ErrorPageDescriptor.class);
  ErrorCodeType errorCode = errorPageType.getErrorCode();
  if (errorCode != null) {
    errorPageDescriptor.setErrorCode(errorCode.getValue().intValue());
  }
  FullyQualifiedClassType exceptionType = errorPageType.getExceptionType();
  if (exceptionType != null) {
    TypeResolver typeResolver = context.peek(TypeResolver.class);
    TypeCache.CachedType<TypeDescriptor> cachedType = typeResolver.resolve(exceptionType.getValue(), context);
    errorPageDescriptor.setExceptionType(cachedType.getTypeDescriptor());
  }
  errorPageDescriptor.setErrorPage(errorPageType.getLocation().getValue());
  return errorPageDescriptor;
}

@Override
public void visit(final String name, final Object value) {
  if (value instanceof Type) {
    String type = SignatureHelper.getType((Type) value);
    ClassValueDescriptor valueDescriptor = createValue(ClassValueDescriptor.class, name);
    valueDescriptor.setValue(visitorHelper.resolveType(type, containingType).getTypeDescriptor());
    addValue(name, valueDescriptor);
  } else {
    PrimitiveValueDescriptor valueDescriptor = createValue(PrimitiveValueDescriptor.class, name);
    TypeDescriptor typeDescriptor = visitorHelper.resolveType(value.getClass().getName(), containingType).getTypeDescriptor();
    valueDescriptor.setType(typeDescriptor);
    valueDescriptor.setValue(value);
    addValue(name, valueDescriptor);
  }
}