public PsiElement resolveInner() {
    final String name = getCanonicalRepresentationText();
    if (name == null) return null;

    final AntElement element = getElement();
    final AntConfigurationBase antConfig = AntConfigurationBase.getInstance(element.getProject());
    AntTarget result = null;

    if (element instanceof AntAntImpl) {
      final PsiFile psiFile = ((AntAntImpl) element).getCalledAntFile();
      if (psiFile != null) {
        AntFile antFile = AntSupport.getAntFile(psiFile);
        if (antFile != null) {
          final AntFile context = null /*antConfig.getEffectiveContextFile(antFile)*/;

          assert context != null;

          final AntProject project = context.getAntProject();
          if (project != null) {
            result = resolveTargetImpl(name, project);
          }
        }
      }
    }

    if (result == null) {
      final AntFile context = null /*antConfig.getEffectiveContextFile(element.getAntFile())*/;

      assert context != null;

      result = resolveTargetImpl(name, context.getAntProject());
    }

    return result;
  }
  @NotNull
  public Object[] getVariants() {
    final AntElement element = getElement();
    if (element instanceof AntAntImpl) {
      final PsiFile psiFile = ((AntAntImpl) element).getCalledAntFile();
      if (psiFile != null) {
        AntFile antFile;
        if (psiFile instanceof AntFile) {
          antFile = (AntFile) psiFile;
        } else {
          antFile = AntSupport.getAntFile(psiFile);
        }
        final AntProject project = (antFile == null) ? null : antFile.getAntProject();
        if (project != null) {
          return project.getTargets();
        }
      }
    }

    List<AntTarget> result = new ArrayList<AntTarget>();

    final AntProject project = element.getAntProject();
    final AntTarget[] targets = project.getTargets();
    for (final AntTarget target : targets) {
      if (target != element) {
        result.add(target);
      }
    }

    ContainerUtil.addAll(result, project.getImportedTargets());

    return result.toArray();
  }
 @Nullable
 private static String getAdditionalDocumentation(PsiElement elem) {
   final XmlTag xmlTag = PsiTreeUtil.getParentOfType(elem, XmlTag.class);
   if (xmlTag == null) {
     return null;
   }
   final AntDomElement antElement = AntSupport.getAntDomElement(xmlTag);
   if (antElement instanceof AntFilesProvider) {
     final List<File> list =
         ((AntFilesProvider) antElement).getFiles(new HashSet<AntFilesProvider>());
     if (list.size() > 0) {
       final @NonNls StringBuilder builder = StringBuilderSpinAllocator.alloc();
       try {
         final XmlTag tag = antElement.getXmlTag();
         if (tag != null) {
           builder.append("<b>");
           builder.append(tag.getName());
           builder.append(":</b>");
         }
         for (File file : list) {
           if (builder.length() > 0) {
             builder.append("<br>");
           }
           builder.append(file.getPath());
         }
         return builder.toString();
       } finally {
         StringBuilderSpinAllocator.dispose(builder);
       }
     }
   }
   return null;
 }
 public AntDomElement fromString(@Nullable @NonNls String s, ConvertContext context) {
   if (s != null) {
     final AntDomElement element = AntSupport.getInvocationAntDomElement(context);
     if (element != null) {
       return findElementById(
           element.getContextAntProject(),
           s,
           CustomAntElementsRegistry.ourIsBuildingClasspathForCustomTagLoading.get());
     }
   }
   return null;
 }
  @Nullable
  private static VirtualFile getHelpFile(final PsiElement element) {
    final XmlTag xmlTag = PsiTreeUtil.getParentOfType(element, XmlTag.class);
    if (xmlTag == null) {
      return null;
    }
    final AntDomElement antElement = AntSupport.getAntDomElement(xmlTag);
    if (antElement == null) {
      return null;
    }
    final AntDomProject antProject = antElement.getAntProject();
    if (antProject == null) {
      return null;
    }
    final AntInstallation installation = antProject.getAntInstallation();
    if (installation == null) {
      return null; // not configured properly and bundled installation missing
    }
    final String antHomeDir = AntInstallation.HOME_DIR.get(installation.getProperties());

    if (antHomeDir == null) {
      return null;
    }

    @NonNls String path = antHomeDir + "/docs/manual";
    String url;
    if (new File(path).exists()) {
      url =
          VirtualFileManager.constructUrl(
              LocalFileSystem.PROTOCOL, FileUtil.toSystemIndependentName(path));
    } else {
      path = antHomeDir + "/docs.zip";
      if (new File(path).exists()) {
        url =
            VirtualFileManager.constructUrl(
                JarFileSystem.PROTOCOL,
                FileUtil.toSystemIndependentName(path)
                    + JarFileSystem.JAR_SEPARATOR
                    + "docs/manual");
      } else {
        return null;
      }
    }

    final VirtualFile documentationRoot = VirtualFileManager.getInstance().findFileByUrl(url);
    if (documentationRoot == null) {
      return null;
    }

    return getHelpFile(antElement, documentationRoot);
  }
  @NotNull
  public PsiReference[] createReferences(
      final GenericDomValue<AntDomElement> genericDomValue,
      final PsiElement element,
      ConvertContext context) {
    final AntDomElement invocationElement = AntSupport.getInvocationAntDomElement(context);
    return new PsiReference[] {
      new AntDomReferenceBase(element, true) {
        public PsiElement resolve() {
          final AntDomElement value = genericDomValue.getValue();
          if (value == null) {
            return null;
          }
          final DomTarget target = DomTarget.getTarget(value, value.getId());
          if (target == null) {
            return null;
          }
          return PomService.convertToPsi(element.getProject(), target);
        }

        @NotNull
        public Object[] getVariants() {
          if (invocationElement == null) {
            return ArrayUtil.EMPTY_OBJECT_ARRAY;
          }
          final Set<String> variants = new LinkedHashSet<String>();
          invocationElement
              .getContextAntProject()
              .accept(
                  new AntDomRecursiveVisitor() {
                    public void visitAntDomElement(AntDomElement element) {
                      final String variant = element.getId().getRawText();
                      if (variant != null) {
                        variants.add(variant);
                      }
                      super.visitAntDomElement(element);
                    }
                  });
          return variants.size() > 0
              ? ArrayUtil.toObjectArray(variants)
              : ArrayUtil.EMPTY_OBJECT_ARRAY;
        }

        public String getUnresolvedMessagePattern() {
          return AntBundle.message("cannot.resolve.refid", getCanonicalText());
        }
      }
    };
  }