Java 类com.intellij.psi.impl.source.HierarchicalMethodSignatureImpl 实例源码

private static void putInMap(PsiClass aClass, Map<MethodSignature, HierarchicalMethodSignature> result,
                         Map<MethodSignature, HierarchicalMethodSignatureImpl> map, HierarchicalMethodSignature hierarchicalMethodSignature,
                         MethodSignature signature) {
  if (!PsiUtil.isAccessible(hierarchicalMethodSignature.getMethod(), aClass, aClass)) return;
  HierarchicalMethodSignatureImpl existing = map.get(signature);
  if (existing == null) {
    HierarchicalMethodSignatureImpl copy = copy(hierarchicalMethodSignature);
    LOG.assertTrue(copy.getMethod().isValid());
    map.put(signature, copy);
  }
  else if (isReturnTypeIsMoreSpecificThan(hierarchicalMethodSignature, existing) && isSuperMethod(aClass, hierarchicalMethodSignature, existing)) {
    HierarchicalMethodSignatureImpl newSuper = copy(hierarchicalMethodSignature);
    mergeSupers(newSuper, existing);
    LOG.assertTrue(newSuper.getMethod().isValid());
    map.put(signature, newSuper);
  }
  else if (isSuperMethod(aClass, existing, hierarchicalMethodSignature)) {
    mergeSupers(existing, hierarchicalMethodSignature);
  }
  // just drop an invalid method declaration there - to highlight accordingly
  else if (!result.containsKey(signature)) {
    LOG.assertTrue(hierarchicalMethodSignature.getMethod().isValid());
    result.put(signature, hierarchicalMethodSignature);
  }
}

private static void putInMap(@NotNull PsiClass aClass,
                             @NotNull Map<MethodSignature, HierarchicalMethodSignature> result,
                             @NotNull Map<MethodSignature, HierarchicalMethodSignatureImpl> map,
                             @NotNull HierarchicalMethodSignature hierarchicalMethodSignature,
                             @NotNull MethodSignature signature) {
  if (!PsiUtil.isAccessible(aClass.getProject(), hierarchicalMethodSignature.getMethod(), aClass, aClass)) return;
  HierarchicalMethodSignatureImpl existing = map.get(signature);
  if (existing == null) {
    HierarchicalMethodSignatureImpl copy = copy(hierarchicalMethodSignature);
    LOG.assertTrue(copy.getMethod().isValid());
    map.put(signature, copy);
  }
  else if (isReturnTypeIsMoreSpecificThan(hierarchicalMethodSignature, existing) && isSuperMethod(aClass, hierarchicalMethodSignature, existing)) {
    HierarchicalMethodSignatureImpl newSuper = copy(hierarchicalMethodSignature);
    mergeSupers(newSuper, existing);
    LOG.assertTrue(newSuper.getMethod().isValid());
    map.put(signature, newSuper);
  }
  else if (isSuperMethod(aClass, existing, hierarchicalMethodSignature)) {
    mergeSupers(existing, hierarchicalMethodSignature);
  }
  // just drop an invalid method declaration there - to highlight accordingly
  else if (!result.containsKey(signature)) {
    LOG.assertTrue(hierarchicalMethodSignature.getMethod().isValid());
    result.put(signature, hierarchicalMethodSignature);
  }
}

@NotNull
private static HierarchicalMethodSignatureImpl copy(@NotNull HierarchicalMethodSignature hi) {
  HierarchicalMethodSignatureImpl hierarchicalMethodSignature = new HierarchicalMethodSignatureImpl(hi);
  for (HierarchicalMethodSignature his : hi.getSuperSignatures()) {
    hierarchicalMethodSignature.addSuperSignature(copy(his));
  }
  return hierarchicalMethodSignature;
}

private static HierarchicalMethodSignatureImpl copy(HierarchicalMethodSignature hi) {
  HierarchicalMethodSignatureImpl hierarchicalMethodSignature = new HierarchicalMethodSignatureImpl(hi);
  for (HierarchicalMethodSignature his : hi.getSuperSignatures()) {
    hierarchicalMethodSignature.addSuperSignature(copy(his));
  }
  return hierarchicalMethodSignature;
}

private static void putInMap(@NotNull PsiClass aClass,
        @NotNull Map<MethodSignature, HierarchicalMethodSignature> result,
        @NotNull Map<MethodSignature, HierarchicalMethodSignatureImpl> map,
        @NotNull HierarchicalMethodSignature hierarchicalMethodSignature,
        @NotNull MethodSignature signature)
{
    HierarchicalMethodSignatureImpl existing = map.get(signature);
    if(existing == null)
    {
        HierarchicalMethodSignatureImpl copy = copy(hierarchicalMethodSignature);
        LOG.assertTrue(copy.getMethod().isValid());
        map.put(signature, copy);
    }
    else if(isReturnTypeIsMoreSpecificThan(hierarchicalMethodSignature, existing) && isSuperMethod(aClass, hierarchicalMethodSignature, existing))
    {
        HierarchicalMethodSignatureImpl newSuper = copy(hierarchicalMethodSignature);
        mergeSupers(newSuper, existing);
        LOG.assertTrue(newSuper.getMethod().isValid());
        map.put(signature, newSuper);
    }
    else if(isSuperMethod(aClass, existing, hierarchicalMethodSignature))
    {
        mergeSupers(existing, hierarchicalMethodSignature);
    }
    // just drop an invalid method declaration there - to highlight accordingly
    else if(!result.containsKey(signature))
    {
        LOG.assertTrue(hierarchicalMethodSignature.getMethod().isValid());
        result.put(signature, hierarchicalMethodSignature);
    }
}

@NotNull
private static HierarchicalMethodSignatureImpl copy(@NotNull HierarchicalMethodSignature hi)
{
    HierarchicalMethodSignatureImpl hierarchicalMethodSignature = new HierarchicalMethodSignatureImpl(hi);
    for(HierarchicalMethodSignature his : hi.getSuperSignatures())
    {
        hierarchicalMethodSignature.addSuperSignature(copy(his));
    }
    return hierarchicalMethodSignature;
}