Example #1
0
  private void checkCompoundIds(Class<?> javaClass) throws IOException {
    String javaClassName = javaClass.getCanonicalName();
    PsiClass psiClass =
        myJavaPsiFacade.findClass(
            javaClassName, GlobalSearchScope.moduleWithLibrariesScope(myModule));
    assertNotNull(psiClass);

    for (java.lang.reflect.Method javaMethod : javaClass.getDeclaredMethods()) {
      Method method =
          new Method(
              Type.getType(javaClass).getInternalName(),
              javaMethod.getName(),
              Type.getMethodDescriptor(javaMethod));
      boolean noKey = javaMethod.getAnnotation(ExpectNoPsiKey.class) != null;
      PsiMethod psiMethod = psiClass.findMethodsByName(javaMethod.getName(), false)[0];
      checkCompoundId(method, psiMethod, noKey);
    }

    for (Constructor<?> constructor : javaClass.getDeclaredConstructors()) {
      Method method =
          new Method(
              Type.getType(javaClass).getInternalName(),
              "<init>",
              Type.getConstructorDescriptor(constructor));
      boolean noKey = constructor.getAnnotation(ExpectNoPsiKey.class) != null;
      PsiMethod[] constructors = psiClass.getConstructors();
      PsiMethod psiMethod = constructors[0];
      checkCompoundId(method, psiMethod, noKey);
    }
  }
Example #2
0
 @NotNull
 public Type typeToType(PsiType type, boolean notNull) {
   Type result = typeToType(type);
   if (notNull) {
     result.convertedToNotNull();
   }
   return result;
 }
 private static String parseMethodViaDescription(
     final String desc, final PsiMethodStubImpl stub, final List<String> args) {
   final String returnType = getTypeText(Type.getReturnType(desc));
   final Type[] argTypes = Type.getArgumentTypes(desc);
   for (Type argType : argTypes) {
     args.add(getTypeText(argType));
   }
   new PsiTypeParameterListStubImpl(stub);
   return returnType;
 }
 @NotNull
 private static TypeInfo fieldTypeViaDescription(@NotNull String desc) {
   Type type = Type.getType(desc);
   final int dim = type.getSort() == Type.ARRAY ? type.getDimensions() : 0;
   if (dim > 0) {
     type = type.getElementType();
   }
   return new TypeInfo(
       getTypeText(type),
       (byte) dim,
       false,
       Collections.<PsiAnnotationStub>emptyList()); // todo read annos from .class file
 }
Example #5
0
  private static void checkLeakingParameters(Class<?> jClass) throws IOException {
    final HashMap<Method, boolean[]> map = new HashMap<Method, boolean[]>();

    // collecting leakedParameters
    final ClassReader classReader =
        new ClassReader(
            new FileInputStream(
                jClass.getResource("/" + jClass.getName().replace('.', '/') + ".class").getFile()));
    classReader.accept(
        new ClassVisitor(Opcodes.ASM5) {
          @Override
          public MethodVisitor visitMethod(
              int access, String name, String desc, String signature, String[] exceptions) {
            final MethodNode node =
                new MethodNode(Opcodes.ASM5, access, name, desc, signature, exceptions);
            final Method method = new Method(classReader.getClassName(), name, desc);
            return new MethodVisitor(Opcodes.ASM5, node) {
              @Override
              public void visitEnd() {
                super.visitEnd();
                try {
                  map.put(
                      method,
                      LeakingParameters.build(classReader.getClassName(), node, false).parameters);
                } catch (AnalyzerException ignore) {
                }
              }
            };
          }
        },
        ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);

    for (java.lang.reflect.Method jMethod : jClass.getDeclaredMethods()) {
      Method method =
          new Method(
              Type.getType(jClass).getInternalName(),
              jMethod.getName(),
              Type.getMethodDescriptor(jMethod));
      Annotation[][] annotations = jMethod.getParameterAnnotations();
      for (int i = 0; i < annotations.length; i++) {
        boolean isLeaking = false;
        Annotation[] parameterAnnotations = annotations[i];
        for (Annotation parameterAnnotation : parameterAnnotations) {
          if (parameterAnnotation.annotationType() == ExpectLeaking.class) {
            isLeaking = true;
          }
        }
        assertEquals(method.toString() + " #" + i, isLeaking, map.get(method)[i]);
      }
    }
  }
    public AnnotationTextCollector(@Nullable String desc, AnnotationResultCallback callback) {
      super(Opcodes.ASM4);
      myCallback = callback;

      myDesc = desc;
      if (desc != null) {
        myBuilder.append('@').append(getTypeText(Type.getType(desc)));
      }
    }
 @NotNull
 private static String getTypeText(@NotNull Type type) {
   final String raw = type.getClassName();
   // As the '$' char is a valid java identifier and is actively used by byte code generators, the
   // problem is
   // which occurrences of this char should be replaced and which should not.
   // Heuristic: replace only those $ occurrences that are surrounded non-"$" chars
   //   (most likely generated by javac to separate inner or anonymous class name)
   //   Leading and trailing $ chars should be left unchanged.
   return raw.indexOf('$') >= 0 ? REGEX_PATTERN.matcher(raw).replaceAll("\\.") : raw;
 }
 private static String getClassName(final String name) {
   return getTypeText(Type.getObjectType(name));
 }
 @Override
 public void visitEnum(final String name, final String desc, final String value) {
   valuePairPrefix(name);
   myBuilder.append(getTypeText(Type.getType(desc))).append(".").append(value);
 }
Example #10
0
 @NotNull
 private List<Type> typesToNotNullableTypeList(@NotNull PsiType[] types) {
   List<Type> result = new LinkedList<Type>(typesToTypeList(types));
   for (Type p : result) p.convertedToNotNull();
   return result;
 }