/** {@inheritDoc} */
  public void setInput(Object information) {
    if (information == null || information instanceof String) {
      inputChanged(null, null);
      return;
    }
    IJavaElement je = (IJavaElement) information;
    ICompilationUnit cu = (ICompilationUnit) je.getAncestor(IJavaElement.COMPILATION_UNIT);
    if (cu != null) fInput = cu;
    else fInput = je.getAncestor(IJavaElement.CLASS_FILE);

    inputChanged(fInput, information);
  }
 /*
  * @see org.eclipse.jdt.internal.ui.viewsupport.JavaUILabelProvider#getForeground(java.lang.Object)
  */
 public Color getForeground(Object element) {
   if (fOutlineContentProvider.isShowingInheritedMembers()) {
     if (element instanceof IJavaElement) {
       IJavaElement je = (IJavaElement) element;
       if (fInput.getElementType() == IJavaElement.CLASS_FILE)
         je = je.getAncestor(IJavaElement.CLASS_FILE);
       else je = je.getAncestor(IJavaElement.COMPILATION_UNIT);
       if (fInput.equals(je)) {
         return null;
       }
     }
     return fForegroundColor;
   }
   return null;
 }
Пример #3
0
 /* (non-Javadoc)
  * @see IJavaSearchScope#encloses(IJavaElement)
  */
 public boolean encloses(IJavaElement element) {
   if (this.elements != null) {
     for (int i = 0, length = this.elements.size(); i < length; i++) {
       IJavaElement scopeElement = (IJavaElement) this.elements.get(i);
       IJavaElement searchedElement = element;
       while (searchedElement != null) {
         if (searchedElement.equals(scopeElement)) return true;
         searchedElement = searchedElement.getParent();
       }
     }
     return false;
   }
   IPackageFragmentRoot root =
       (IPackageFragmentRoot) element.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
   if (root != null && root.isArchive()) {
     // external or internal jar
     IPath rootPath = root.getPath();
     String rootPathToString =
         rootPath.getDevice() == null ? rootPath.toString() : rootPath.toOSString();
     IPath relativePath = getPath(element, true /*relative path*/);
     return indexOf(rootPathToString, relativePath.toString()) >= 0;
   }
   // resource in workspace
   String fullResourcePathString = getPath(element, false /*full path*/).toString();
   return indexOf(fullResourcePathString) >= 0;
 }
Пример #4
0
  /**
   * @see
   *     edu.buffalo.cse.green.RefactorHandler#handleMove(edu.buffalo.cse.green.editor.model.RootModel,
   *     org.eclipse.jdt.core.IJavaElement, org.eclipse.jdt.core.IJavaElement)
   */
  public void handleMove(RootModel root, E sourceElement, E targetElement) {
    // get all types represented in the diagram
    String scuId = sourceElement.getHandleIdentifier();
    String tcuId = targetElement.getHandleIdentifier();

    String scuName = scuId.substring(scuId.indexOf('{') + 1, scuId.indexOf(".java"));
    String tcuName = tcuId.substring(tcuId.indexOf('{') + 1, tcuId.indexOf(".java"));

    List<IJavaElement> cuTypes = root.getElementsOfKind(TYPE);

    // see if any types belong to the compilation unit
    // that is undergoing the move event
    for (IJavaElement oType : cuTypes) {
      if (JavaModelListener.sameElements(sourceElement, oType.getAncestor(COMPILATION_UNIT))) {
        String oId = oType.getHandleIdentifier();
        String oName = oId.substring(oId.indexOf('['));

        oName = oName.replaceAll("\\[" + scuName, "[" + tcuName);

        IJavaElement nType = JavaCore.create(tcuId + oName);
        TypeModel oModel = (TypeModel) root.getModelFromElement(oType);

        TypeModel nModel = root.createTypeModel((IType) nType);
        if (oModel != null) {
          // TODO We tried to catch a ResourceException,
          // but it is caught in MemberModel
          oModel.removeFromParent();
          nModel.setLocation(oModel.getLocation());
          nModel.setSize(oModel.getSize());
        }
      }
    }
  }
 protected IPackageFragmentRoot getFragmentRoot(IJavaElement elem) {
   IPackageFragmentRoot initRoot = null;
   if (elem != null) {
     initRoot = (IPackageFragmentRoot) elem.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
     try {
       if (initRoot == null || initRoot.getKind() != IPackageFragmentRoot.K_SOURCE) {
         IJavaProject jproject = elem.getJavaProject();
         if (jproject != null) {
           initRoot = null;
           if (jproject.exists()) {
             IPackageFragmentRoot[] roots = jproject.getPackageFragmentRoots();
             for (int i = 0; i < roots.length; i++) {
               if (roots[i].getKind() == IPackageFragmentRoot.K_SOURCE) {
                 initRoot = roots[i];
                 break;
               }
             }
           }
           if (initRoot == null) {
             initRoot = jproject.getPackageFragmentRoot(jproject.getResource());
           }
         }
       }
     } catch (JavaModelException e) {
       // TODO
       e.printStackTrace();
     }
   }
   return initRoot;
 }
Пример #6
0
  /**
   * @see
   *     edu.buffalo.cse.green.RefactorHandler#handleRemove(edu.buffalo.cse.green.editor.model.RootModel,
   *     org.eclipse.jdt.core.IJavaElement)
   */
  public void handleRemove(RootModel root, E element) {
    List<IJavaElement> cus = root.getElementsOfKind(COMPILATION_UNIT);

    for (IJavaElement cu : cus) {
      if (JavaModelListener.sameElements(cu.getAncestor(PACKAGE_FRAGMENT), element)) {
        CompilationUnitRefactorHandler.instance().handleRemove(root, (ICompilationUnit) cu);
      }
    }
  }
Пример #7
0
  /**
   * @see
   *     edu.buffalo.cse.green.RefactorHandler#handleRemove(edu.buffalo.cse.green.editor.model.RootModel,
   *     org.eclipse.jdt.core.IJavaElement)
   */
  public void handleRemove(RootModel root, E element) {
    List<IJavaElement> packages = root.getElementsOfKind(PACKAGE_FRAGMENT);

    for (IJavaElement pack : packages) {
      // get the project that contains the package
      IJavaElement proj = pack.getAncestor(JAVA_PROJECT);

      // if the package belongs to the project, remove it
      if (JavaModelListener.sameElements(proj, element)) {
        PackageRefactorHandler.instance().handleRemove(root, (IPackageFragment) pack);
      }
    }
  }
Пример #8
0
  /**
   * @see
   *     edu.buffalo.cse.green.RefactorHandler#handleRemove(edu.buffalo.cse.green.editor.model.RootModel,
   *     org.eclipse.jdt.core.IJavaElement)
   */
  public void handleRemove(RootModel root, E element) {
    // ignore this if the CU removed is a working copy (not actual removal)
    if (element.isWorkingCopy()) return;

    List<IJavaElement> types = new ArrayList<IJavaElement>(root.getElementsOfKind(TYPE));

    // remove any types that belong to the compilation unit
    for (IJavaElement type : types) {
      if (JavaModelListener.sameElements(element, type.getAncestor(COMPILATION_UNIT))) {
        if (root.getModelFromElement(type) != null) {
          root.getModelFromElement(type).removeFromParent();
        }
      }
    }
  }
Пример #9
0
 /* (non-Javadoc)
  * @see org.eclipse.jdt.core.search.SearchRequestor#acceptSearchMatch(org.eclipse.jdt.core.search.SearchMatch)
  */
 public void acceptSearchMatch(SearchMatch match) {
   IJavaElement enclosingElement = (IJavaElement) match.getElement();
   try {
     if ((enclosingElement != null)
         && (enclosingElement.getElementType() == IJavaElement.TYPE)) {
       String packName =
           enclosingElement.getAncestor(IJavaElement.PACKAGE_FRAGMENT).getElementName();
       Set deps = new HashSet();
       store.put(enclosingElement.getHandleIdentifier(), deps);
       Set typesInPackage = (Set) packages.get(packName);
       if (typesInPackage == null) {
         typesInPackage = new HashSet();
         packages.put(packName, typesInPackage);
       }
       typesInPackage.add(enclosingElement.getHandleIdentifier());
     }
   } catch (Throwable e) {
     e.printStackTrace();
   }
 }
  /**
   * @param dontSearchInit: not applicable for this method (ignored)
   * @return the module that corresponds to the passed name.
   */
  public IModule getModuleInDirectManager(
      String name, IPythonNature nature, boolean dontSearchInit) {
    if (DEBUG_GET_MODULE) {
      System.out.println("Trying to get module in java project modules manager: " + name);
    }
    if (name.startsWith(".")) { // this happens when looking for a relative import
      return null;
    }
    try {
      IJavaElement javaElement = this.javaProject.findType(name);
      if (javaElement == null) {
        javaElement = this.javaProject.findElement(new Path(name.replace('.', '/')));
      }

      if (DEBUG_GET_MODULE) {
        System.out.println("Found: " + javaElement);
      }

      if (javaElement != null) {

        // now, there's a catch here, we'll find any class in the project classpath, even if it's in
        // the
        // global classpath (e.g.: rt.jar), and this shouldn't be treated in this project modules
        // manager
        // (that's treated in the Jython system manager)
        IJavaElement ancestor = javaElement.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
        if (ancestor instanceof IPackageFragmentRoot) {
          IPackageFragmentRoot packageFragmentRoot = (IPackageFragmentRoot) ancestor;
          IClasspathEntry rawClasspathEntry = packageFragmentRoot.getRawClasspathEntry();
          if (rawClasspathEntry.getEntryKind() == IClasspathEntry.CPE_CONTAINER) {
            return null;
          }
        }
        return new JavaModuleInProject(name, this.javaProject);
      }
    } catch (Exception e) {
      throw new RuntimeException(e);
    }
    return null;
  }
Пример #11
0
 private boolean isEnabled(IStructuredSelection selection) {
   Object[] selected = selection.toArray();
   for (int i = 0; i < selected.length; i++) {
     try {
       if (selected[i] instanceof IJavaElement) {
         IJavaElement elem = (IJavaElement) selected[i];
         if (elem.exists()) {
           switch (elem.getElementType()) {
             case IJavaElement.TYPE:
               return elem.getParent().getElementType()
                   == IJavaElement.COMPILATION_UNIT; // for browsing perspective
             case IJavaElement.COMPILATION_UNIT:
               return true;
             case IJavaElement.IMPORT_CONTAINER:
               return true;
             case IJavaElement.PACKAGE_FRAGMENT:
             case IJavaElement.PACKAGE_FRAGMENT_ROOT:
               IPackageFragmentRoot root =
                   (IPackageFragmentRoot) elem.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
               return (root.getKind() == IPackageFragmentRoot.K_SOURCE);
             case IJavaElement.JAVA_PROJECT:
               // https://bugs.eclipse.org/bugs/show_bug.cgi?id=65638
               return true;
           }
         }
       } else if (selected[i] instanceof LogicalPackage) {
         return true;
       } else if (selected[i] instanceof IWorkingSet) {
         IWorkingSet workingSet = (IWorkingSet) selected[i];
         return IWorkingSetIDs.JAVA.equals(workingSet.getId());
       }
     } catch (JavaModelException e) {
       if (!e.isDoesNotExist()) {
         JavaPlugin.log(e);
       }
     }
   }
   return false;
 }
Пример #12
0
 protected TypedElement createTypedElement(IJavaElement javaElement, BitSet modes) {
   String name;
   IClassFile classFile = (IClassFile) javaElement.getAncestor(IJavaElement.CLASS_FILE);
   // existing read-only class files
   if (classFile != null) {
     name = classFile.getPath().toOSString();
     if (!name.endsWith(".class")) { // $NON-NLS-1$
       name += '/' + JdtUtils.getFullBytecodeName(classFile);
     }
   } else {
     // usual eclipse - generated bytecode
     name = JdtUtils.getByteCodePath(javaElement);
   }
   String methodName = null;
   if (javaElement.getElementType() == IJavaElement.METHOD
       || javaElement.getElementType() == IJavaElement.INITIALIZER) {
     methodName = JdtUtils.getMethodSignature(javaElement);
     if (methodName != null) {
       name += ":" + methodName;
     }
   }
   return new TypedElement(name, methodName, TypedElement.TYPE_BYTECODE, javaElement, modes);
 }
Пример #13
0
 /** @see AbstractJavaSearchScope#packageFragmentRoot(String, int, String) */
 public IPackageFragmentRoot packageFragmentRoot(
     String resourcePathString, int jarSeparatorIndex, String jarPath) {
   int index = -1;
   boolean isJarFile = jarSeparatorIndex != -1;
   if (isJarFile) {
     // internal or external jar (case 3, 4, or 5)
     String relativePath = resourcePathString.substring(jarSeparatorIndex + 1);
     index = indexOf(jarPath, relativePath);
   } else {
     // resource in workspace (case 1 or 2)
     index = indexOf(resourcePathString);
   }
   if (index >= 0) {
     int idx = this.projectIndexes[index];
     String projectPath = idx == -1 ? null : (String) this.projectPaths.get(idx);
     if (projectPath != null) {
       IJavaProject project =
           JavaCore.create(ResourcesPlugin.getWorkspace().getRoot().getProject(projectPath));
       if (isJarFile) {
         IResource resource = JavaModel.getWorkspaceTarget(new Path(jarPath));
         if (resource != null) return project.getPackageFragmentRoot(resource);
         return project.getPackageFragmentRoot(jarPath);
       }
       Object target =
           JavaModel.getWorkspaceTarget(
               new Path(this.containerPaths[index] + '/' + this.relativePaths[index]));
       if (target != null) {
         if (target instanceof IProject) {
           return project.getPackageFragmentRoot((IProject) target);
         }
         IJavaElement element = JavaModelManager.create((IResource) target, project);
         return (IPackageFragmentRoot) element.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
       }
     }
   }
   return null;
 }
Пример #14
0
 public RefCollector(Set store, Set handles, IJavaElement from) {
   this.store = store;
   this.types = handles;
   this.from = from;
   this.fromPackage = from.getAncestor(IJavaElement.PACKAGE_FRAGMENT);
 }
Пример #15
0
  /**
   * Add an element to the java search scope.
   *
   * @param element The element we want to add to current java search scope
   * @throws JavaModelException May happen if some Java Model info are not available
   */
  public void add(IJavaElement element) throws JavaModelException {
    IPath containerPath = null;
    String containerPathToString = null;
    PackageFragmentRoot root = null;
    int includeMask = SOURCES | APPLICATION_LIBRARIES | SYSTEM_LIBRARIES;
    switch (element.getElementType()) {
      case IJavaElement.JAVA_MODEL:
        // a workspace sope should be used
        break;
      case IJavaElement.JAVA_PROJECT:
        add((JavaProject) element, null, includeMask, new HashSet(2), new HashSet(2), null);
        break;
      case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        root = (PackageFragmentRoot) element;
        IPath rootPath = root.internalPath();
        containerPath =
            root.getKind() == IPackageFragmentRoot.K_SOURCE ? root.getParent().getPath() : rootPath;
        containerPathToString =
            containerPath.getDevice() == null
                ? containerPath.toString()
                : containerPath.toOSString();
        IResource rootResource = root.resource();
        String projectPath = root.getJavaProject().getPath().toString();
        if (rootResource != null && rootResource.isAccessible()) {
          String relativePath =
              Util.relativePath(rootResource.getFullPath(), containerPath.segmentCount());
          add(projectPath, relativePath, containerPathToString, false /*not a package*/, null);
        } else {
          add(projectPath, "", containerPathToString, false /*not a package*/, null); // $NON-NLS-1$
        }
        break;
      case IJavaElement.PACKAGE_FRAGMENT:
        root = (PackageFragmentRoot) element.getParent();
        projectPath = root.getJavaProject().getPath().toString();
        if (root.isArchive()) {
          String relativePath = Util.concatWith(((PackageFragment) element).names, '/');
          containerPath = root.getPath();
          containerPathToString =
              containerPath.getDevice() == null
                  ? containerPath.toString()
                  : containerPath.toOSString();
          add(projectPath, relativePath, containerPathToString, true /*package*/, null);
        } else {
          IResource resource = ((JavaElement) element).resource();
          if (resource != null) {
            if (resource.isAccessible()) {
              containerPath =
                  root.getKind() == IPackageFragmentRoot.K_SOURCE
                      ? root.getParent().getPath()
                      : root.internalPath();
            } else {
              // for working copies, get resource container full path
              containerPath = resource.getParent().getFullPath();
            }
            containerPathToString =
                containerPath.getDevice() == null
                    ? containerPath.toString()
                    : containerPath.toOSString();
            String relativePath =
                Util.relativePath(resource.getFullPath(), containerPath.segmentCount());
            add(projectPath, relativePath, containerPathToString, true /*package*/, null);
          }
        }
        break;
      default:
        // remember sub-cu (or sub-class file) java elements
        if (element instanceof IMember) {
          if (this.elements == null) {
            this.elements = new ArrayList();
          }
          this.elements.add(element);
        }
        root = (PackageFragmentRoot) element.getAncestor(IJavaElement.PACKAGE_FRAGMENT_ROOT);
        projectPath = root.getJavaProject().getPath().toString();
        String relativePath;
        if (root.getKind() == IPackageFragmentRoot.K_SOURCE) {
          containerPath = root.getParent().getPath();
          relativePath =
              Util.relativePath(
                  getPath(element, false /*full path*/),
                  root.getJavaProject().getPath().segmentCount() /*remove project segment*/);
        } else {
          containerPath = root.internalPath();
          relativePath = getPath(element, true /*relative path*/).toString();
        }
        containerPathToString =
            containerPath.getDevice() == null
                ? containerPath.toString()
                : containerPath.toOSString();
        add(projectPath, relativePath, containerPathToString, false /*not a package*/, null);
    }

    if (root != null)
      addEnclosingProjectOrJar(
          root.getKind() == IPackageFragmentRoot.K_SOURCE
              ? root.getParent().getPath()
              : root.getPath());
  }
Пример #16
0
  public static URL getJavadocLocation(IJavaElement element, boolean includeMemberReference)
      throws JavaModelException {
    URL baseLocation = getJavadocBaseLocation(element);
    if (baseLocation == null) {
      return null;
    }

    String urlString = baseLocation.toExternalForm();

    StringBuffer urlBuffer = new StringBuffer(urlString);
    if (!urlString.endsWith("/")) { // $NON-NLS-1$
      urlBuffer.append('/');
    }

    StringBuffer pathBuffer = new StringBuffer();
    StringBuffer fragmentBuffer = new StringBuffer();

    switch (element.getElementType()) {
      case IJavaElement.PACKAGE_FRAGMENT:
        appendPackageSummaryPath((IPackageFragment) element, pathBuffer);
        break;
      case IJavaElement.JAVA_PROJECT:
      case IJavaElement.PACKAGE_FRAGMENT_ROOT:
        appendIndexPath(pathBuffer);
        break;
      case IJavaElement.IMPORT_CONTAINER:
        element = element.getParent();
        // $FALL-THROUGH$
      case IJavaElement.COMPILATION_UNIT:
        IType mainType = ((ICompilationUnit) element).findPrimaryType();
        if (mainType == null) {
          return null;
        }
        appendTypePath(mainType, pathBuffer);
        break;
      case IJavaElement.CLASS_FILE:
        appendTypePath(((IClassFile) element).getType(), pathBuffer);
        break;
      case IJavaElement.TYPE:
        appendTypePath((IType) element, pathBuffer);
        break;
      case IJavaElement.FIELD:
        IField field = (IField) element;
        appendTypePath(field.getDeclaringType(), pathBuffer);
        if (includeMemberReference) {
          appendFieldReference(field, fragmentBuffer);
        }
        break;
      case IJavaElement.METHOD:
        IMethod method = (IMethod) element;
        appendTypePath(method.getDeclaringType(), pathBuffer);
        if (includeMemberReference) {
          appendMethodReference(method, fragmentBuffer);
        }
        break;
      case IJavaElement.INITIALIZER:
        appendTypePath(((IMember) element).getDeclaringType(), pathBuffer);
        break;
      case IJavaElement.IMPORT_DECLARATION:
        IImportDeclaration decl = (IImportDeclaration) element;

        if (decl.isOnDemand()) {
          IJavaElement cont =
              JavaModelUtil.findTypeContainer(
                  element.getJavaProject(), Signature.getQualifier(decl.getElementName()));
          if (cont instanceof IType) {
            appendTypePath((IType) cont, pathBuffer);
          } else if (cont instanceof IPackageFragment) {
            appendPackageSummaryPath((IPackageFragment) cont, pathBuffer);
          }
        } else {
          IType imp = element.getJavaProject().findType(decl.getElementName());
          appendTypePath(imp, pathBuffer);
        }
        break;
      case IJavaElement.PACKAGE_DECLARATION:
        IJavaElement pack = element.getAncestor(IJavaElement.PACKAGE_FRAGMENT);
        if (pack != null) {
          appendPackageSummaryPath((IPackageFragment) pack, pathBuffer);
        } else {
          return null;
        }
        break;
      default:
        return null;
    }

    try {
      String fragment = fragmentBuffer.length() == 0 ? null : fragmentBuffer.toString();
      try {
        URI relativeURI = new URI(null, null, pathBuffer.toString(), fragment);
        urlBuffer.append(relativeURI.toString());
        return new URL(urlBuffer.toString());
      } catch (URISyntaxException e) {
        JavaPlugin.log(e);
        return new URL(urlBuffer.append(pathBuffer).toString());
      }
    } catch (MalformedURLException e) {
      JavaPlugin.log(e);
    }
    return null;
  }
Пример #17
0
  /**
   * Finds the key defined by the given match. The assumption is that the key is the only argument
   * and it is a string literal i.e. quoted ("...") or a string constant i.e. 'static final String'
   * defined in the same class.
   *
   * @param keyPositionResult reference parameter: will be filled with the position of the found key
   * @param enclosingElement enclosing java element
   * @return a string denoting the key, {@link #NO_KEY} if no key can be found and <code>null</code>
   *     otherwise
   * @throws CoreException if a problem occurs while accessing the <code>enclosingElement</code>
   */
  private String findKey(Position keyPositionResult, IJavaElement enclosingElement)
      throws CoreException {
    ICompilationUnit unit =
        (ICompilationUnit) enclosingElement.getAncestor(IJavaElement.COMPILATION_UNIT);
    if (unit == null) return null;

    String source = unit.getSource();
    if (source == null) return null;

    IJavaProject javaProject = unit.getJavaProject();
    IScanner scanner = null;
    if (javaProject != null) {
      String complianceLevel = javaProject.getOption(JavaCore.COMPILER_COMPLIANCE, true);
      String sourceLevel = javaProject.getOption(JavaCore.COMPILER_SOURCE, true);
      scanner = ToolFactory.createScanner(false, false, false, sourceLevel, complianceLevel);
    } else {
      scanner = ToolFactory.createScanner(false, false, false, false);
    }
    scanner.setSource(source.toCharArray());
    scanner.resetTo(keyPositionResult.getOffset() + keyPositionResult.getLength(), source.length());

    try {
      if (scanner.getNextToken() != ITerminalSymbols.TokenNameDOT) return null;

      if (scanner.getNextToken() != ITerminalSymbols.TokenNameIdentifier) return null;

      String src = new String(scanner.getCurrentTokenSource());
      int tokenStart = scanner.getCurrentTokenStartPosition();
      int tokenEnd = scanner.getCurrentTokenEndPosition();

      if (scanner.getNextToken() == ITerminalSymbols.TokenNameLPAREN) {
        // Old school
        // next must be key string. Ignore methods which do not take a single String parameter (Bug
        // 295040).
        int nextToken = scanner.getNextToken();
        if (nextToken != ITerminalSymbols.TokenNameStringLiteral
            && nextToken != ITerminalSymbols.TokenNameIdentifier) return null;

        tokenStart = scanner.getCurrentTokenStartPosition();
        tokenEnd = scanner.getCurrentTokenEndPosition();
        int token;
        while ((token = scanner.getNextToken()) == ITerminalSymbols.TokenNameDOT) {
          if ((nextToken = scanner.getNextToken()) != ITerminalSymbols.TokenNameIdentifier) {
            return null;
          }
          tokenStart = scanner.getCurrentTokenStartPosition();
          tokenEnd = scanner.getCurrentTokenEndPosition();
        }
        if (token != ITerminalSymbols.TokenNameRPAREN) return null;

        if (nextToken == ITerminalSymbols.TokenNameStringLiteral) {
          keyPositionResult.setOffset(tokenStart + 1);
          keyPositionResult.setLength(tokenEnd - tokenStart - 1);
          return source.substring(tokenStart + 1, tokenEnd);
        } else if (nextToken == ITerminalSymbols.TokenNameIdentifier) {
          keyPositionResult.setOffset(tokenStart);
          keyPositionResult.setLength(tokenEnd - tokenStart + 1);
          IType parentClass = (IType) enclosingElement.getAncestor(IJavaElement.TYPE);
          IField[] fields = parentClass.getFields();
          String identifier = source.substring(tokenStart, tokenEnd + 1);
          for (int i = 0; i < fields.length; i++) {
            if (fields[i].getElementName().equals(identifier)) {
              if (!Signature.getSignatureSimpleName(fields[i].getTypeSignature())
                  .equals("String")) // $NON-NLS-1$
              return null;
              Object obj = fields[i].getConstant();
              return obj instanceof String
                  ? ((String) obj).substring(1, ((String) obj).length() - 1)
                  : NO_KEY;
            }
          }
        }
        return NO_KEY;
      } else {
        keyPositionResult.setOffset(tokenStart);
        keyPositionResult.setLength(tokenEnd - tokenStart + 1);
        return src;
      }
    } catch (InvalidInputException e) {
      throw new CoreException(JavaUIStatus.createError(IStatus.ERROR, e));
    }
  }