Esempio n. 1
0
  /**
   * Determines is the java element contains a type with a specific annotation.
   *
   * <p>The syntax for the property tester is of the form: qualified or unqualified annotation name
   * <li>qualified or unqualified annotation name, required. For example, <code>org.junit.JUnit
   *     </code>.
   * </ol>
   *
   * @param element the element to check for the method
   * @param annotationName the qualified or unqualified name of the annotation to look for
   * @return true if the type is found in the element, false otherwise
   */
  private boolean hasTypeWithAnnotation(IJavaElement element, String annotationType) {
    try {
      IType type = getType(element);
      if (type == null || !type.exists()) {
        return false;
      }

      IBuffer buffer = null;
      IOpenable openable = type.getOpenable();
      if (openable instanceof ICompilationUnit) {
        buffer = ((ICompilationUnit) openable).getBuffer();
      } else if (openable instanceof IClassFile) {
        buffer = ((IClassFile) openable).getBuffer();
      }
      if (buffer == null) {
        return false;
      }

      ISourceRange sourceRange = type.getSourceRange();
      ISourceRange nameRange = type.getNameRange();
      if (sourceRange != null && nameRange != null) {
        IScanner scanner = ToolFactory.createScanner(false, false, true, false);
        scanner.setSource(buffer.getCharacters());
        scanner.resetTo(sourceRange.getOffset(), nameRange.getOffset());
        if (findAnnotation(scanner, annotationType)) {
          return true;
        }
      }
    } catch (JavaModelException e) {
    } catch (InvalidInputException e) {
    }
    return false;
  }
  private void failHelper1(
      int startLine,
      int startColumn,
      int endLine,
      int endColumn,
      boolean makeFinal,
      String className,
      int visibility,
      int expectedSeverity)
      throws Exception {
    ICompilationUnit cu = createCUfromTestFile(getPackageP(), false, true);
    ISourceRange selection =
        TextRangeUtil.getSelection(cu, startLine, startColumn, endLine, endColumn);
    ConvertAnonymousToNestedRefactoring ref =
        new ConvertAnonymousToNestedRefactoring(cu, selection.getOffset(), selection.getLength());

    RefactoringStatus preconditionResult = ref.checkInitialConditions(new NullProgressMonitor());
    if (preconditionResult.isOK()) preconditionResult = null;
    assertEquals("activation was supposed to be successful", null, preconditionResult);

    ref.setClassName(className);
    ref.setDeclareFinal(makeFinal);
    ref.setVisibility(visibility);

    if (preconditionResult == null)
      preconditionResult = ref.checkFinalConditions(new NullProgressMonitor());
    else preconditionResult.merge(ref.checkFinalConditions(new NullProgressMonitor()));
    if (preconditionResult.isOK()) preconditionResult = null;
    assertNotNull("precondition was supposed to fail", preconditionResult);

    assertEquals("incorrect severity:", expectedSeverity, preconditionResult.getSeverity());
  }
Esempio n. 3
0
 private void addDeclarationUpdate() throws CoreException {
   ISourceRange nameRange = fField.getNameRange();
   TextEdit textEdit =
       new ReplaceEdit(nameRange.getOffset(), nameRange.getLength(), getNewElementName());
   ICompilationUnit cu = fField.getCompilationUnit();
   String groupName = RefactoringCoreMessages.RenameFieldRefactoring_Update_field_declaration;
   addTextEdit(fChangeManager.get(cu), groupName, textEdit);
 }
Esempio n. 4
0
 /**
  * Default strategy for when no source position can be computed: creates a {@link Position} for
  * the name of the given {@link IType}. Returns <code>null</code> in the event the given {@link
  * IType} is <code>null</code> or the name range cannot be computed for the type.
  *
  * @param type the type
  * @param reference the reference
  * @throws CoreException
  * @return returns a default {@link Position} for the name range of the given {@link IType}
  */
 protected Position defaultSourcePosition(IType type, IReference reference) throws CoreException {
   if (type != null) {
     ISourceRange range = type.getNameRange();
     if (range != null) {
       return new Position(range.getOffset(), range.getLength());
     }
   }
   return null;
 }
Esempio n. 5
0
 public ASTNode search() throws JavaModelException {
   ISourceRange range = null;
   if (this.element instanceof IMember && !(this.element instanceof IInitializer))
     range = ((IMember) this.element).getNameRange();
   else range = this.element.getSourceRange();
   this.rangeStart = range.getOffset();
   this.rangeLength = range.getLength();
   this.ast.accept(this);
   return this.foundNode;
 }
 public void run(IStructuredSelection selection) {
   IMember member = getMember(selection);
   if (!ActionUtil.isProcessable(getShell(), member)) return;
   FindOccurrencesEngine engine = FindOccurrencesEngine.create(new OccurrencesFinder());
   try {
     ISourceRange range = member.getNameRange();
     String result = engine.run(member.getTypeRoot(), range.getOffset(), range.getLength());
     if (result != null) showMessage(getShell(), fActionBars, result);
   } catch (JavaModelException e) {
     JavaPlugin.log(e);
   }
 }
  private void failActivationHelper(
      int startLine, int startColumn, int endLine, int endColumn, int expectedSeverity)
      throws Exception {
    ICompilationUnit cu = createCUfromTestFile(getPackageP(), false, true);
    ISourceRange selection =
        TextRangeUtil.getSelection(cu, startLine, startColumn, endLine, endColumn);
    ConvertAnonymousToNestedRefactoring ref =
        new ConvertAnonymousToNestedRefactoring(cu, selection.getOffset(), selection.getLength());

    RefactoringStatus preconditionResult = ref.checkInitialConditions(new NullProgressMonitor());
    assertEquals(
        "activation was supposed to fail", expectedSeverity, preconditionResult.getSeverity());
  }
  CalleeAnalyzerVisitor(
      IMember member, CompilationUnit compilationUnit, IProgressMonitor progressMonitor) {
    fSearchResults = new CallSearchResultCollector();
    this.fMember = member;
    this.fCompilationUnit = compilationUnit;
    this.fProgressMonitor = progressMonitor;

    try {
      ISourceRange sourceRange = member.getSourceRange();
      this.fMethodStartPosition = sourceRange.getOffset();
      this.fMethodEndPosition = fMethodStartPosition + sourceRange.getLength();
    } catch (JavaModelException jme) {
      JavaPlugin.log(jme);
    }
  }
Esempio n. 9
0
 /**
  * Returns the source range to use for the given field within the given {@link IType}
  *
  * @param type the type to look in for the given {@link IApiField}
  * @param reference the reference the field is involved in
  * @param field the field to find the range for
  * @return the {@link ISourceRange} in the given {@link IType} that encloses the given {@link
  *     IApiField}
  * @throws JavaModelException
  * @throws CoreException
  */
 protected Position getSourceRangeForField(IType type, IReference reference, IApiField field)
     throws JavaModelException, CoreException {
   IField javaField = type.getField(field.getName());
   Position pos = null;
   if (javaField.exists()) {
     ISourceRange range = javaField.getNameRange();
     if (range != null) {
       pos = new Position(range.getOffset(), range.getLength());
     }
   }
   if (pos == null) {
     return defaultSourcePosition(type, reference);
   }
   return pos;
 }
Esempio n. 10
0
 /**
  * Returns the source range for the given {@link IApiMethod} within the given {@link IType}
  *
  * @param type the type to look for the method within
  * @param reference the reference the method comes from
  * @param method the {@link IApiMethod} to look for the source range for
  * @return the {@link ISourceRange} in the {@link IType} enclosing the given {@link IApiMethod}
  * @throws CoreException
  * @throws JavaModelException
  */
 protected Position getSourceRangeForMethod(IType type, IReference reference, IApiMethod method)
     throws CoreException, JavaModelException {
   IMethod match = findMethodInType(type, method);
   Position pos = null;
   if (match != null) {
     ISourceRange range = match.getNameRange();
     if (range != null) {
       pos = new Position(range.getOffset(), range.getLength());
     }
   }
   if (pos == null) {
     return defaultSourcePosition(type, reference);
   }
   return pos;
 }
Esempio n. 11
0
 @Override
 public void run(IStructuredSelection selection) {
   try {
     IMember member = getMember(selection);
     if (member == null || !ActionUtil.isEditable(getShell(), member)) return;
     ISourceRange range = member.getNameRange();
     RefactoringExecutionStarter.startChangeTypeRefactoring(
         member.getCompilationUnit(), getShell(), range.getOffset(), range.getLength());
   } catch (CoreException e) {
     ExceptionHandler.handle(
         e,
         RefactoringMessages.ChangeTypeAction_dialog_title,
         RefactoringMessages.ChangeTypeAction_exception);
   }
 }
Esempio n. 12
0
 /**
  * Method getPosition. Get position for workspace java source files
  *
  * @param aSelectedElement ISourceReference
  * @param aFile IFile
  * @return TextPosition
  * @throws CoreException
  */
 public static R4EUITextPosition getPosition(ISourceReference aSelectedElement, IFile aFile)
     throws CoreException {
   int offset = 0;
   int length = 0;
   String name = "";
   if (null != aSelectedElement) {
     final ISourceRange sourceRange = aSelectedElement.getSourceRange();
     if (null != sourceRange) {
       offset = sourceRange.getOffset();
       length = sourceRange.getLength();
     }
     name = ((IJavaElement) aSelectedElement).getElementName();
   }
   final R4EUITextPosition position = new R4EUITextPosition(offset, length, aFile);
   position.setName(name);
   return position;
 }
Esempio n. 13
0
 /**
  * Formats the specified compilation unit.
  *
  * @param unit the compilation unit to format
  * @param monitor the monitor for the operation
  * @throws JavaModelException
  */
 public static void formatUnitSourceCode(ICompilationUnit unit, IProgressMonitor monitor)
     throws JavaModelException {
   CodeFormatter formatter = ToolFactory.createCodeFormatter(null);
   ISourceRange range = unit.getSourceRange();
   TextEdit formatEdit =
       formatter.format(
           CodeFormatter.K_COMPILATION_UNIT,
           unit.getSource(),
           range.getOffset(),
           range.getLength(),
           0,
           null);
   if (formatEdit != null && formatEdit.hasChildren()) {
     unit.applyTextEdit(formatEdit, monitor);
   } else {
     monitor.done();
   }
 }
Esempio n. 14
0
 /** @see ISourceReference */
 public String getSource() throws JavaModelException {
   IOpenable openable = this.parent.getOpenableParent();
   IBuffer buffer = openable.getBuffer();
   if (buffer == null) {
     return null;
   }
   ISourceRange range = getSourceRange();
   int offset = range.getOffset();
   int length = range.getLength();
   if (offset == -1 || length == 0) {
     return null;
   }
   try {
     return buffer.getText(offset, length);
   } catch (RuntimeException e) {
     return null;
   }
 }
  @Override
  public RefactoringStatus checkInitialConditions(IProgressMonitor pm)
      throws CoreException, OperationCanceledException {

    RefactoringStatus result = new RefactoringStatus();
    result.merge(Checks.checkAvailability(targetClass));

    if (result.hasFatalError()) return result;

    fRoot = new RefactoringASTParser(AST.JLS3).parse(targetClass.getCompilationUnit(), true, pm);
    ISourceRange sourceRange = targetClass.getNameRange();

    ASTNode node = NodeFinder.perform(fRoot, sourceRange.getOffset(), sourceRange.getLength());
    if (node == null) {
      return mappingErrorFound(result, node);
    } else {
      targetClassDeclaration = ASTNodeSearchUtil.getTypeDeclarationNode(targetClass, fRoot);
    }
    fRewriter = ASTRewrite.create(fRoot.getAST());
    return result;
  }
  private void helper1(
      int startLine,
      int startColumn,
      int endLine,
      int endColumn,
      boolean makeFinal,
      boolean makeStatic,
      String className,
      int visibility)
      throws Exception {
    ICompilationUnit cu = createCUfromTestFile(getPackageP(), true, true);
    ISourceRange selection =
        TextRangeUtil.getSelection(cu, startLine, startColumn, endLine, endColumn);
    ConvertAnonymousToNestedRefactoring ref =
        new ConvertAnonymousToNestedRefactoring(cu, selection.getOffset(), selection.getLength());

    RefactoringStatus preconditionResult = ref.checkInitialConditions(new NullProgressMonitor());
    if (preconditionResult.isOK()) preconditionResult = null;
    assertEquals("activation was supposed to be successful", null, preconditionResult);

    ref.setClassName(className);
    ref.setDeclareFinal(makeFinal);
    ref.setDeclareStatic(makeStatic);
    ref.setVisibility(visibility);

    if (preconditionResult == null)
      preconditionResult = ref.checkFinalConditions(new NullProgressMonitor());
    else preconditionResult.merge(ref.checkFinalConditions(new NullProgressMonitor()));
    if (preconditionResult.isOK()) preconditionResult = null;
    assertEquals("precondition was supposed to pass", null, preconditionResult);

    performChange(ref, false);

    IPackageFragment pack = (IPackageFragment) cu.getParent();
    String newCuName = getSimpleTestFileName(true, true);
    ICompilationUnit newcu = pack.getCompilationUnit(newCuName);
    assertTrue(newCuName + " does not exist", newcu.exists());
    assertEqualLines(getFileContents(getTestFileName(true, false)), newcu.getSource());
  }
 /*
  * (non-Javadoc)
  * @see org.eclipse.pde.api.tools.internal.builder.AbstractProblemDetector#
  * getSourceRange(org.eclipse.jdt.core.IType,
  * org.eclipse.jface.text.IDocument,
  * org.eclipse.pde.api.tools.internal.provisional.builder.IReference)
  */
 @Override
 protected Position getSourceRange(IType type, IDocument document, IReference reference)
     throws CoreException, BadLocationException {
   switch (reference.getReferenceType()) {
     case IReference.T_TYPE_REFERENCE:
       {
         int linenumber = reference.getLineNumber();
         if (linenumber > 0) {
           // line number starts at 0 for the
           linenumber--;
         }
         if (linenumber > 0) {
           int offset = document.getLineOffset(linenumber);
           String line = document.get(offset, document.getLineLength(linenumber));
           String qname = reference.getReferencedTypeName().replace('$', '.');
           int first = line.indexOf(qname);
           if (first < 0) {
             qname = Signatures.getSimpleTypeName(reference.getReferencedTypeName());
             qname = qname.replace('$', '.');
             first = line.indexOf(qname);
           }
           Position pos = null;
           if (first > -1) {
             pos = new Position(offset + first, qname.length());
           } else {
             // optimistically select the whole line since we can't
             // find the correct variable name and we can't just
             // select
             // the first occurrence
             pos = new Position(offset, line.length());
           }
           return pos;
         } else {
           IApiMember apiMember = reference.getMember();
           switch (apiMember.getType()) {
             case IApiElement.FIELD:
               {
                 IApiField field = (IApiField) reference.getMember();
                 return getSourceRangeForField(type, reference, field);
               }
             case IApiElement.METHOD:
               {
                 // reference in a method declaration
                 IApiMethod method = (IApiMethod) reference.getMember();
                 return getSourceRangeForMethod(type, reference, method);
               }
             default:
               break;
           }
           // reference in a type declaration
           ISourceRange range = type.getNameRange();
           Position pos = null;
           if (range != null) {
             pos = new Position(range.getOffset(), range.getLength());
           }
           if (pos == null) {
             return defaultSourcePosition(type, reference);
           }
           return pos;
         }
       }
     case IReference.T_FIELD_REFERENCE:
       {
         int linenumber = reference.getLineNumber();
         if (linenumber > 0) {
           return getFieldNameRange(
               reference.getReferencedTypeName(),
               reference.getReferencedMemberName(),
               document,
               reference);
         }
         // reference in a field declaration
         IApiField field = (IApiField) reference.getMember();
         return getSourceRangeForField(type, reference, field);
       }
     case IReference.T_METHOD_REFERENCE:
       {
         if (reference.getLineNumber() >= 0) {
           String referenceMemberName = reference.getReferencedMemberName();
           String methodName = null;
           boolean isConstructor = Util.isConstructor(referenceMemberName);
           if (isConstructor) {
             methodName =
                 Signatures.getSimpleTypeName(reference.getReferencedTypeName().replace('$', '.'));
           } else {
             methodName = referenceMemberName;
           }
           Position pos = getMethodNameRange(isConstructor, methodName, document, reference);
           if (pos == null) {
             return defaultSourcePosition(type, reference);
           }
           return pos;
         }
         // reference in a method declaration
         IApiMethod method = (IApiMethod) reference.getMember();
         return getSourceRangeForMethod(type, reference, method);
       }
     default:
       return null;
   }
 }
Esempio n. 18
0
  /**
   * Determines is the java element contains a method with a specific annotation.
   *
   * <p>The syntax for the property tester is of the form: qualified or unqualified annotation name,
   * modifiers
   * <li>qualified or unqualified annotation name, required. For example, <code>org.junit.JUnit
   *     </code>.
   * <li>modifiers - optional space separated list of modifiers, for example, <code>public static
   *     </code>.
   * </ol>
   *
   * @param element the element to check for the method
   * @param annotationName the qualified or unqualified name of the annotation to look for
   * @return true if the method is found in the element, false otherwise
   */
  private boolean hasMethodWithAnnotation(IJavaElement element, Object[] args) {
    try {
      String annotationType = (String) args[0];
      int flags = 0;
      if (args.length > 1) {
        String[] modifiers = ((String) args[1]).split(" "); // $NON-NLS-1$
        for (int j = 0; j < modifiers.length; j++) {
          String modifier = modifiers[j];
          Integer flag = (Integer) fgModifiers.get(modifier);
          if (flag != null) {
            flags = flags | flag.intValue();
          }
        }
      } else {
        flags = -1;
      }

      IType type = getType(element);
      if (type == null || !type.exists()) {
        return false;
      }
      IMethod[] methods = type.getMethods();
      if (methods.length == 0) {
        return false;
      }

      IBuffer buffer = null;
      IOpenable openable = type.getOpenable();
      if (openable instanceof ICompilationUnit) {
        buffer = ((ICompilationUnit) openable).getBuffer();
      } else if (openable instanceof IClassFile) {
        buffer = ((IClassFile) openable).getBuffer();
      }
      if (buffer == null) {
        return false;
      }
      IScanner scanner = null; // delay initialization

      for (int i = 0; i < methods.length; i++) {
        IMethod curr = methods[i];
        if (curr.isConstructor() || (flags != -1 && flags != (curr.getFlags() & FLAGS_MASK))) {
          continue;
        }

        ISourceRange sourceRange = curr.getSourceRange();
        ISourceRange nameRange = curr.getNameRange();
        if (sourceRange != null && nameRange != null) {
          if (scanner == null) {
            scanner = ToolFactory.createScanner(false, false, true, false);
            scanner.setSource(buffer.getCharacters());
          }
          scanner.resetTo(sourceRange.getOffset(), nameRange.getOffset());
          if (findAnnotation(scanner, annotationType)) {
            return true;
          }
        }
      }
    } catch (JavaModelException e) {
    } catch (InvalidInputException e) {
    }
    return false;
  }
 private void doListSelectionChanged(int page, ISourceRange[] ranges) {
   if (fEditor != null && ranges != null && page >= 0 && page < ranges.length) {
     ISourceRange range = ranges[page];
     fEditor.selectAndReveal(range.getOffset(), range.getLength());
   }
 }
Esempio n. 20
0
  public IDocInfo getBasicDocInfo() {
    try {
      IMethod iMethod = (IMethod) tm;
      ISourceRange javadocRange = iMethod.getJavadocRange();
      if (javadocRange != null) {
        String attachedJavadoc =
            iMethod
                .getCompilationUnit()
                .getSource()
                .substring(
                    javadocRange.getOffset(), javadocRange.getOffset() + javadocRange.getLength());
        attachedJavadoc = attachedJavadoc.substring(3, attachedJavadoc.length() - 2);
        StringReader rr = new StringReader(attachedJavadoc);
        BufferedReader mm = new BufferedReader(rr);
        final StringBuilder bld = new StringBuilder();
        final HashMap<String, String> mmq = new HashMap<String, String>();
        while (true) {
          try {
            String s = mm.readLine();
            if (s == null) {
              break;
            }
            int indexOf = s.indexOf('*');
            if (indexOf != -1) {
              s = s.substring(indexOf + 1);
            }
            s = s.trim();
            if (s.startsWith("@")) { // $NON-NLS-1$
              if (s.startsWith(PARAM)) {
                s = s.substring(PARAM.length());
                s = s.trim();
                int p = s.indexOf(' ');
                if (p != -1) {
                  String pName = s.substring(0, p).trim();
                  String pVal = s.substring(p).trim();
                  mmq.put(pName, pVal);
                }
              }
              if (s.startsWith(RETURN)) {
                s = s.substring(RETURN.length());
                s = s.trim();
                mmq.put(RETURN, s);
              }
              continue;
            }
            bld.append(s);
            bld.append('\n');
          } catch (IOException e) {
            break;
          }
        }
        return new IDocInfo() {

          public String getDocumentation(String pName) {
            return mmq.get(pName);
          }

          public String getDocumentation() {
            return bld.toString().trim();
          }

          public String getReturnInfo() {
            return mmq.get(RETURN);
          }
        };
      }
      return new IDocInfo() {

        public String getReturnInfo() {
          return ""; //$NON-NLS-1$
        }

        public String getDocumentation(String pName) {
          return ""; //$NON-NLS-1$
        }

        public String getDocumentation() {
          return ""; //$NON-NLS-1$
        }
      };
    } catch (JavaModelException e) {
      throw new IllegalStateException();
    }
  }
  /**
   * Invokes the introduce indirection ref. Some pointers:
   *
   * @param topLevelName This is an array of fully qualified top level(!) type names with exactly
   *     one package prefix (e.g. "p.Foo"). Simple names must correspond to .java files. The first
   *     cu will be used for the invocation of the refactoring (see positioning)
   * @param newName name of indirection method
   * @param qTypeName qualified type name of the type for the indirection method. Should be one of
   *     the cus in topLevelName.
   * @param startLine starting line of selection in topLevelName[0]
   * @param startColumn starting column of selection in topLevelName[0]
   * @param endLine ending line of selection in topLevelName[0]
   * @param endColumn ending column of selection in topLevelName[0]
   * @param updateReferences true if references should be updated
   * @param shouldWarn if true, warnings will be expected in the result
   * @param shouldError if true, errors will be expected in the result
   * @param shouldFail if true, fatal errors will be expected in the result
   * @throws Exception
   * @throws JavaModelException
   * @throws CoreException
   * @throws IOException
   */
  private void helper(
      String[] topLevelName,
      String newName,
      String qTypeName,
      int startLine,
      int startColumn,
      int endLine,
      int endColumn,
      boolean updateReferences,
      boolean shouldWarn,
      boolean shouldError,
      boolean shouldFail)
      throws Exception, JavaModelException, CoreException, IOException {
    ICompilationUnit[] cu = new ICompilationUnit[topLevelName.length];
    for (int i = 0; i < topLevelName.length; i++) {
      String packName = topLevelName[i].substring(0, topLevelName[i].indexOf('.'));
      String className = topLevelName[i].substring(topLevelName[i].indexOf('.') + 1);
      IPackageFragment cPackage = getRoot().createPackageFragment(packName, true, null);
      cu[i] = createCUfromTestFile(cPackage, className);
    }

    ISourceRange selection =
        TextRangeUtil.getSelection(cu[0], startLine, startColumn, endLine, endColumn);
    try {
      IntroduceIndirectionRefactoring ref =
          new IntroduceIndirectionRefactoring(cu[0], selection.getOffset(), selection.getLength());
      ref.setEnableUpdateReferences(updateReferences);
      if (qTypeName != null) ref.setIntermediaryClassName(qTypeName);
      if (newName != null) ref.setIntermediaryMethodName(newName);

      boolean failed = false;
      RefactoringStatus status = performRefactoringWithStatus(ref);
      if (status.hasFatalError()) {
        assertTrue(
            "Failed but shouldn't: " + status.getMessageMatchingSeverity(RefactoringStatus.FATAL),
            shouldFail);
        failed = true;
      } else assertFalse("Didn't fail although expected", shouldFail);

      if (!failed) {

        if (status.hasError())
          assertTrue(
              "Had errors but shouldn't: "
                  + status.getMessageMatchingSeverity(RefactoringStatus.ERROR),
              shouldError);
        else assertFalse("No error although expected", shouldError);

        if (status.hasWarning())
          assertTrue(
              "Had warnings but shouldn't: "
                  + status.getMessageMatchingSeverity(RefactoringStatus.WARNING),
              shouldWarn);
        else assertFalse("No warning although expected", shouldWarn);

        for (int i = 0; i < topLevelName.length; i++) {
          String className = topLevelName[i].substring(topLevelName[i].indexOf('.') + 1);
          assertEqualLines(
              "invalid output.",
              getFileContents(getOutputTestFileName(className)),
              cu[i].getSource());
        }
      }
    } finally {
      for (int i = 0; i < topLevelName.length; i++) JavaProjectHelper.delete(cu[i]);
    }
  }