4d7be341f95fc8ddc567956d1edebf52c8b83281
[phpeclipse.git] / net.sourceforge.phpeclipse / src / net / sourceforge / phpdt / internal / core / CompilationUnit.java
1 /*******************************************************************************
2  * Copyright (c) 2000, 2003 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/cpl-v10.html
7  *
8  * Contributors:
9  *     IBM Corporation - initial API and implementation
10  *******************************************************************************/
11 package net.sourceforge.phpdt.internal.core;
12
13 import java.util.ArrayList;
14 import java.util.HashMap;
15 import java.util.Map;
16
17 import net.sourceforge.phpdt.core.IBuffer;
18 import net.sourceforge.phpdt.core.IBufferFactory;
19 import net.sourceforge.phpdt.core.ICodeAssist;
20 import net.sourceforge.phpdt.core.ICompilationUnit;
21 import net.sourceforge.phpdt.core.IImportContainer;
22 import net.sourceforge.phpdt.core.IImportDeclaration;
23 import net.sourceforge.phpdt.core.IJavaElement;
24 import net.sourceforge.phpdt.core.IJavaModelStatusConstants;
25 import net.sourceforge.phpdt.core.IJavaProject;
26 import net.sourceforge.phpdt.core.IMember;
27 import net.sourceforge.phpdt.core.IMethod;
28 import net.sourceforge.phpdt.core.IOpenable;
29 import net.sourceforge.phpdt.core.IPackageDeclaration;
30 import net.sourceforge.phpdt.core.IPackageFragmentRoot;
31 import net.sourceforge.phpdt.core.IParent;
32 import net.sourceforge.phpdt.core.IProblemRequestor;
33 import net.sourceforge.phpdt.core.ISourceManipulation;
34 import net.sourceforge.phpdt.core.ISourceRange;
35 import net.sourceforge.phpdt.core.ISourceReference;
36 import net.sourceforge.phpdt.core.IType;
37 import net.sourceforge.phpdt.core.IWorkingCopy;
38 import net.sourceforge.phpdt.core.JavaModelException;
39 import net.sourceforge.phpdt.core.Signature;
40 import net.sourceforge.phpdt.core.WorkingCopyOwner;
41 import net.sourceforge.phpdt.core.compiler.CharOperation;
42 import net.sourceforge.phpdt.core.jdom.IDOMNode;
43 import net.sourceforge.phpdt.internal.compiler.IProblemFactory;
44 import net.sourceforge.phpdt.internal.compiler.SourceElementParser;
45 import net.sourceforge.phpdt.internal.compiler.ast.CompilationUnitDeclaration;
46 import net.sourceforge.phpdt.internal.compiler.impl.CompilerOptions;
47 import net.sourceforge.phpdt.internal.compiler.problem.DefaultProblemFactory;
48 import net.sourceforge.phpdt.internal.core.util.MementoTokenizer;
49 import net.sourceforge.phpdt.internal.core.util.Util;
50
51 import org.eclipse.core.resources.IContainer;
52 import org.eclipse.core.resources.IFile;
53 import org.eclipse.core.resources.IMarker;
54 import org.eclipse.core.resources.IResource;
55 import org.eclipse.core.runtime.IPath;
56 import org.eclipse.core.runtime.IProgressMonitor;
57 import org.eclipse.core.runtime.Path;
58
59 /**
60  * @see ICompilationUnit
61  */
62
63 public class CompilationUnit extends Openable implements ICompilationUnit,
64     net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit {
65   public WorkingCopyOwner owner;
66   /**
67    * Constructs a handle to a compilation unit with the given name in the specified package for the specified owner
68    *
69    * @exception IllegalArgumentException
70    *              if the name of the compilation unit does not end with ".java"
71    */
72   protected CompilationUnit(PackageFragment parent, String name, WorkingCopyOwner owner) {
73     super(parent, name);
74     this.owner = owner;
75   }
76
77   /**
78    * Accepts the given visitor onto the parsed tree of this compilation unit, after having runned the name resolution. The visitor's
79    * corresponding <code>visit</code> method is called with the corresponding parse tree. If the visitor returns <code>true</code>,
80    * this method visits this parse node's members.
81    *
82    * @param visitor
83    *          the visitor
84    * @exception JavaModelException
85    *              if this method fails. Reasons include:
86    *              <ul>
87    *              <li>This element does not exist.</li>
88    *              <li>The visitor failed with this exception.</li>
89    *              </ul>
90    */
91   //public void accept(IAbstractSyntaxTreeVisitor visitor) throws JavaModelException {
92   //    CompilationUnitVisitor.visit(this, visitor);
93   //}
94   /*
95    * @see ICompilationUnit#becomeWorkingCopy(IProblemRequestor, IProgressMonitor)
96    */
97   public void becomeWorkingCopy(IProblemRequestor problemRequestor, IProgressMonitor monitor) throws JavaModelException {
98     JavaModelManager manager = JavaModelManager.getJavaModelManager();
99     JavaModelManager.PerWorkingCopyInfo perWorkingCopyInfo = manager.getPerWorkingCopyInfo(this, false/* don't create */,
100         true /* record usage */, null/* no problem requestor needed */);
101     if (perWorkingCopyInfo == null) {
102       // close cu and its children
103       close();
104
105       BecomeWorkingCopyOperation operation = new BecomeWorkingCopyOperation(this, problemRequestor);
106       operation.runOperation(monitor);
107     }
108   }
109
110   //protected void buildStructure(OpenableElementInfo info, IProgressMonitor monitor) throws JavaModelException {
111   //
112   //    if (monitor != null && monitor.isCanceled()) return;
113   //
114   //    // remove existing (old) infos
115   //    removeInfo();
116   //
117   //    HashMap newElements = new HashMap(11);
118   //    info.setIsStructureKnown(generateInfos(info, monitor, newElements, getResource()));
119   //    JavaModelManager.getJavaModelManager().getElementsOutOfSynchWithBuffers().remove(this);
120   //    for (Iterator iter = newElements.keySet().iterator(); iter.hasNext();) {
121   //            IJavaElement key = (IJavaElement) iter.next();
122   //            Object value = newElements.get(key);
123   //            JavaModelManager.getJavaModelManager().putInfo(key, value);
124   //    }
125   //    // add the info for this at the end, to ensure that a getInfo cannot reply null in case the LRU cache needs
126   //    // to be flushed. Might lead to performance issues.
127   //    // see PR 1G2K5S7: ITPJCORE:ALL - NPE when accessing source for a binary type
128   //    JavaModelManager.getJavaModelManager().putInfo(this, info);
129   //}
130   protected boolean buildStructure(OpenableElementInfo info, final IProgressMonitor pm, Map newElements,
131       IResource underlyingResource) throws JavaModelException {
132
133     // check if this compilation unit can be opened
134     if (!isWorkingCopy()) { // no check is done on root kind or exclusion pattern for working copies
135       if ( // ((IPackageFragment)getParent()).getKind() == IPackageFragmentRoot.K_BINARY||
136       !isValidCompilationUnit() || !underlyingResource.isAccessible()) {
137         throw newNotPresentException();
138       }
139     }
140
141     // prevents reopening of non-primary working copies (they are closed when they are discarded and should not be reopened)
142     if (!isPrimary() && getPerWorkingCopyInfo() == null) {
143       throw newNotPresentException();
144     }
145
146     CompilationUnitElementInfo unitInfo = (CompilationUnitElementInfo) info;
147
148     // get buffer contents
149     IBuffer buffer = getBufferManager().getBuffer(CompilationUnit.this);
150     if (buffer == null) {
151       buffer = openBuffer(pm, unitInfo); // open buffer independently from the info, since we are building the info
152     }
153     final char[] contents = buffer == null ? null : buffer.getCharacters();
154
155     // generate structure and compute syntax problems if needed
156     CompilationUnitStructureRequestor requestor = new CompilationUnitStructureRequestor(this, unitInfo, newElements);
157     JavaModelManager.PerWorkingCopyInfo perWorkingCopyInfo = getPerWorkingCopyInfo();
158     IJavaProject project = getJavaProject();
159     boolean computeProblems = JavaProject.hasJavaNature(project.getProject()) && perWorkingCopyInfo != null
160         && perWorkingCopyInfo.isActive();
161     IProblemFactory problemFactory = new DefaultProblemFactory();
162     Map options = project.getOptions(true);
163
164     if (underlyingResource == null) {
165       underlyingResource = getResource();
166     }
167
168     SourceElementParser parser = new SourceElementParser(requestor, problemFactory,
169         new CompilerOptions(options));
170     //, true/*report local declarations*/);
171     requestor.parser = parser;
172     CompilationUnitDeclaration unit = parser.parseCompilationUnit(
173         new net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit() {
174           public char[] getContents() {
175             return contents;
176           }
177
178           public char[] getMainTypeName() {
179             return CompilationUnit.this.getMainTypeName();
180           }
181
182           public char[][] getPackageName() {
183             return CompilationUnit.this.getPackageName();
184           }
185
186           public char[] getFileName() {
187             return CompilationUnit.this.getFileName();
188           }
189
190           public IResource getResource() {
191             return CompilationUnit.this.getResource();
192           }
193         }, true /* full parse to find local elements */);
194
195     // update timestamp (might be IResource.NULL_STAMP if original does not exist)
196
197     unitInfo.timestamp = ((IFile) underlyingResource).getModificationStamp();
198     // compute other problems if needed
199     CompilationUnitDeclaration compilationUnitDeclaration = null;
200     try {
201       if (computeProblems) {
202         perWorkingCopyInfo.beginReporting();
203         compilationUnitDeclaration = CompilationUnitProblemFinder.process(unit, this, contents, parser, this.owner,
204             perWorkingCopyInfo, problemFactory, false/* don't cleanup cu */, pm);
205         perWorkingCopyInfo.endReporting();
206       }
207
208       //                if (info instanceof ASTHolderCUInfo) {
209       //                        int astLevel = ((ASTHolderCUInfo) info).astLevel;
210       //                        net.sourceforge.phpdt.core.dom.CompilationUnit cu = AST.convertCompilationUnit(astLevel, unit, contents, options, pm);
211       //                        ((ASTHolderCUInfo) info).ast = cu;
212       //                }
213     } finally {
214       if (compilationUnitDeclaration != null) {
215         compilationUnitDeclaration.cleanUp();
216       }
217     }
218
219     return unitInfo.isStructureKnown();
220   }
221
222   ///**
223   // * @see ICodeAssist#codeComplete(int, ICompletionRequestor)
224   // */
225   //public void codeComplete(int offset, ICompletionRequestor requestor) throws JavaModelException {
226   //    codeComplete(this, isWorkingCopy() ? (net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit) getOriginalElement() : this,
227   // offset, requestor);
228   //}
229   /**
230    * @see ICodeAssist#codeSelect(int, int)
231    */
232   //public IJavaElement[] codeSelect(int offset, int length) throws JavaModelException {
233   //    return super.codeSelect(this, offset, length);
234   //}
235   /**
236    * @see IWorkingCopy#commit(boolean, IProgressMonitor)
237    */
238   public void commit(boolean force, IProgressMonitor monitor) throws JavaModelException {
239     commitWorkingCopy(force, monitor);
240     //  throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.INVALID_ELEMENT_TYPES, this));
241   }
242
243   /**
244    * @see ICompilationUnit#commitWorkingCopy(boolean, IProgressMonitor)
245    */
246   public void commitWorkingCopy(boolean force, IProgressMonitor monitor) throws JavaModelException {
247     CommitWorkingCopyOperation op = new CommitWorkingCopyOperation(this, force);
248     op.runOperation(monitor);
249   }
250
251   /**
252    * @see ISourceManipulation#copy(IJavaElement, IJavaElement, String, boolean, IProgressMonitor)
253    */
254   public void copy(IJavaElement container, IJavaElement sibling, String rename, boolean force, IProgressMonitor monitor)
255       throws JavaModelException {
256     if (container == null) {
257       throw new IllegalArgumentException(Util.bind("operation.nullContainer")); //$NON-NLS-1$
258     }
259     IJavaElement[] elements = new IJavaElement[] { this };
260     IJavaElement[] containers = new IJavaElement[] { container };
261     String[] renamings = null;
262     if (rename != null) {
263       renamings = new String[] { rename };
264     }
265     getJavaModel().copy(elements, containers, null, renamings, force, monitor);
266   }
267
268   /**
269    * Returns a new element info for this element.
270    */
271   protected Object createElementInfo() {
272     return new CompilationUnitElementInfo();
273   }
274
275   ///**
276   // * @see ICompilationUnit#createImport(String, IJavaElement, IProgressMonitor)
277   // */
278   //public IImportDeclaration createImport(String name, IJavaElement sibling, IProgressMonitor monitor) throws JavaModelException {
279   //    CreateImportOperation op = new CreateImportOperation(name, this);
280   //    if (sibling != null) {
281   //            op.createBefore(sibling);
282   //    }
283   //    runOperation(op, monitor);
284   //    return getImport(name);
285   //}
286   /**
287    * @see ICompilationUnit#createPackageDeclaration(String, IProgressMonitor)
288    */
289   public IPackageDeclaration createPackageDeclaration(String name, IProgressMonitor monitor) throws JavaModelException {
290
291     CreatePackageDeclarationOperation op = new CreatePackageDeclarationOperation(name, this);
292     runOperation(op, monitor);
293     return getPackageDeclaration(name);
294   }
295
296   ///**
297   // * @see ICompilationUnit#createType(String, IJavaElement, boolean, IProgressMonitor)
298   // */
299   //public IType createType(String content, IJavaElement sibling, boolean force, IProgressMonitor monitor) throws
300   // JavaModelException {
301   //    if (!exists()) {
302   //            //autogenerate this compilation unit
303   //            IPackageFragment pkg = (IPackageFragment) getParent();
304   //            String source = ""; //$NON-NLS-1$
305   //            if (pkg.getElementName().length() > 0) {
306   //                    //not the default package...add the package declaration
307   //                    source = "package " + pkg.getElementName() + ";" + net.sourceforge.phpdt.internal.compiler.util.ProjectPrefUtil.LINE_SEPARATOR +
308   // net.sourceforge.phpdt.internal.compiler.util.ProjectPrefUtil.LINE_SEPARATOR; //$NON-NLS-1$ //$NON-NLS-2$
309   //            }
310   //            CreateCompilationUnitOperation op = new CreateCompilationUnitOperation(pkg, fName, source, force);
311   //            runOperation(op, monitor);
312   //    }
313   //    CreateTypeOperation op = new CreateTypeOperation(this, content, force);
314   //    if (sibling != null) {
315   //            op.createBefore(sibling);
316   //    }
317   //    runOperation(op, monitor);
318   //    return (IType) op.getResultElements()[0];
319   //}
320   /**
321    * @see ISourceManipulation#delete(boolean, IProgressMonitor)
322    */
323   public void delete(boolean force, IProgressMonitor monitor) throws JavaModelException {
324     IJavaElement[] elements = new IJavaElement[] { this };
325     getJavaModel().delete(elements, force, monitor);
326   }
327
328   /**
329    * @see IWorkingCopy#destroy()
330    * @deprecated
331    */
332   public void destroy() {
333     try {
334       discardWorkingCopy();
335     } catch (JavaModelException e) {
336       e.printStackTrace();
337     }
338   }
339
340   /*
341    * @see ICompilationUnit#discardWorkingCopy
342    */
343   public void discardWorkingCopy() throws JavaModelException {
344     // discard working copy and its children
345     DiscardWorkingCopyOperation op = new DiscardWorkingCopyOperation(this);
346     op.runOperation(null);
347   }
348
349   /**
350    * Returns true if this handle represents the same Java element as the given handle.
351    *
352    * @see Object#equals(java.lang.Object)
353    */
354   public boolean equals(Object obj) {
355     if (!(obj instanceof CompilationUnit))
356       return false;
357     CompilationUnit other = (CompilationUnit) obj;
358     return this.owner.equals(other.owner) && super.equals(obj);
359   }
360
361   /**
362    * @see JavaElement#equalsDOMNode(IDOMNode)
363    */
364   protected boolean equalsDOMNode(IDOMNode node) throws JavaModelException {
365     String name = getElementName();
366     if (node.getNodeType() == IDOMNode.COMPILATION_UNIT && name != null) {
367       String nodeName = node.getName();
368       if (nodeName == null)
369         return false;
370       if (name.equals(nodeName)) {
371         return true;
372       } else {
373         // iterate through all the types inside the receiver and see if one of them can fit
374         IType[] types = getTypes();
375         String typeNodeName = nodeName.substring(0, nodeName.indexOf(".java")); //$NON-NLS-1$
376         for (int i = 0, max = types.length; i < max; i++) {
377           if (types[i].getElementName().equals(typeNodeName)) {
378             return true;
379           }
380         }
381       }
382     }
383     return false;
384   }
385
386   /**
387    * @see IWorkingCopy#findElements(IJavaElement)
388    */
389   public IJavaElement[] findElements(IJavaElement element) {
390     ArrayList children = new ArrayList();
391     while (element != null && element.getElementType() != IJavaElement.COMPILATION_UNIT) {
392       children.add(element);
393       element = element.getParent();
394     }
395     if (element == null)
396       return null;
397     IJavaElement currentElement = this;
398     for (int i = children.size() - 1; i >= 0; i--) {
399       IJavaElement child = (IJavaElement) children.get(i);
400       switch (child.getElementType()) {
401       //                        case IJavaElement.PACKAGE_DECLARATION:
402       //                                currentElement = ((ICompilationUnit)currentElement).getPackageDeclaration(child.getElementName());
403       //                                break;
404       //                        case IJavaElement.IMPORT_CONTAINER:
405       //                                currentElement = ((ICompilationUnit)currentElement).getImportContainer();
406       //                                break;
407       //                        case IJavaElement.IMPORT_DECLARATION:
408       //                                currentElement = ((IImportContainer)currentElement).getImport(child.getElementName());
409       //                                break;
410       case IJavaElement.TYPE:
411         if (currentElement.getElementType() == IJavaElement.COMPILATION_UNIT) {
412           currentElement = ((ICompilationUnit) currentElement).getType(child.getElementName());
413         } else {
414           currentElement = ((IType) currentElement).getType(child.getElementName());
415         }
416         break;
417       //                        case IJavaElement.INITIALIZER:
418       //                                currentElement = ((IType)currentElement).getInitializer(((JavaElement)child).getOccurrenceCount());
419       //                                break;
420       case IJavaElement.FIELD:
421         currentElement = ((IType) currentElement).getField(child.getElementName());
422         break;
423       case IJavaElement.METHOD:
424         return ((IType) currentElement).findMethods((IMethod) child);
425       }
426
427     }
428     if (currentElement != null && currentElement.exists()) {
429       return new IJavaElement[] { currentElement };
430     } else {
431       return null;
432     }
433   }
434
435   /**
436    * @see IWorkingCopy#findPrimaryType()
437    */
438   public IType findPrimaryType() {
439     String typeName = Signature.getQualifier(this.getElementName());
440     IType primaryType = this.getType(typeName);
441     if (primaryType.exists()) {
442       return primaryType;
443     }
444     return null;
445   }
446
447   /**
448    * @see IWorkingCopy#findSharedWorkingCopy(IBufferFactory)
449    * @deprecated
450    */
451   public IJavaElement findSharedWorkingCopy(IBufferFactory factory) {
452
453     // if factory is null, default factory must be used
454     if (factory == null)
455       factory = this.getBufferManager().getDefaultBufferFactory();
456
457     return findWorkingCopy(BufferFactoryWrapper.create(factory));
458   }
459
460   /**
461    * @see ICompilationUnit#findWorkingCopy(WorkingCopyOwner)
462    */
463   public ICompilationUnit findWorkingCopy(WorkingCopyOwner workingCopyOwner) {
464     CompilationUnit cu = new CompilationUnit((PackageFragment) this.parent, getElementName(), workingCopyOwner);
465     if (workingCopyOwner == DefaultWorkingCopyOwner.PRIMARY) {
466       return cu;
467     } else {
468       // must be a working copy
469       JavaModelManager.PerWorkingCopyInfo perWorkingCopyInfo = cu.getPerWorkingCopyInfo();
470       if (perWorkingCopyInfo != null) {
471         return perWorkingCopyInfo.getWorkingCopy();
472       } else {
473         return null;
474       }
475     }
476   }
477
478   //protected boolean generateInfos(OpenableElementInfo info, IProgressMonitor pm, Map newElements, IResource underlyingResource)
479   // throws JavaModelException {
480   //
481   //// if (getParent() instanceof JarPackageFragment) {
482   //// // ignore .java files in jar
483   //// throw newNotPresentException();
484   //// } else {
485   //            // put the info now, because getting the contents requires it
486   //            JavaModelManager.getJavaModelManager().putInfo(this, info);
487   //            CompilationUnitElementInfo unitInfo = (CompilationUnitElementInfo) info;
488   //
489   //            // generate structure
490   //            CompilationUnitStructureRequestor requestor = new CompilationUnitStructureRequestor(this, unitInfo, newElements);
491   //            IProblemFactory factory = new DefaultProblemFactory();
492   //            SourceElementParser parser = new SourceElementParser(requestor, factory, new
493   // CompilerOptions(getJavaProject().getOptions(true)));
494   //// SourceElementParser parser = new SourceElementParser(requestor, factory);
495   //            requestor.parser = parser;
496   //            parser.parseCompilationUnit(this, false);
497   //            if (isWorkingCopy()) {
498   //                    CompilationUnit original = (CompilationUnit) getOriginalElement();
499   //                    // might be IResource.NULL_STAMP if original does not exist
500   //                    unitInfo.timestamp = ((IFile) original.getResource()).getModificationStamp();
501   //            }
502   //            return unitInfo.isStructureKnown();
503   //// }
504   //}
505   /**
506    * @see ICompilationUnit#getAllTypes()
507    */
508   public IType[] getAllTypes() throws JavaModelException {
509     IJavaElement[] types = getTypes();
510     int i;
511     ArrayList allTypes = new ArrayList(types.length);
512     ArrayList typesToTraverse = new ArrayList(types.length);
513     for (i = 0; i < types.length; i++) {
514       typesToTraverse.add(types[i]);
515     }
516     while (!typesToTraverse.isEmpty()) {
517       IType type = (IType) typesToTraverse.get(0);
518       typesToTraverse.remove(type);
519       allTypes.add(type);
520       types = type.getTypes();
521       for (i = 0; i < types.length; i++) {
522         typesToTraverse.add(types[i]);
523       }
524     }
525     IType[] arrayOfAllTypes = new IType[allTypes.size()];
526     allTypes.toArray(arrayOfAllTypes);
527     return arrayOfAllTypes;
528   }
529
530   /**
531    * @see IMember#getCompilationUnit()
532    */
533   public ICompilationUnit getCompilationUnit() {
534     return this;
535   }
536
537   /**
538    * @see net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit#getContents()
539    */
540   public char[] getContents() {
541     try {
542       IBuffer buffer = this.getBuffer();
543       return buffer == null ? null : buffer.getCharacters();
544     } catch (JavaModelException e) {
545       return CharOperation.NO_CHAR;
546     }
547   }
548
549   /**
550    * A compilation unit has a corresponding resource unless it is contained in a jar.
551    *
552    * @see IJavaElement#getCorrespondingResource()
553    */
554   public IResource getCorrespondingResource() throws JavaModelException {
555     IPackageFragmentRoot root = (IPackageFragmentRoot) getParent().getParent();
556     if (root.isArchive()) {
557       return null;
558     } else {
559       return getUnderlyingResource();
560     }
561   }
562
563   /**
564    * @see ICompilationUnit#getElementAt(int)
565    */
566   public IJavaElement getElementAt(int position) throws JavaModelException {
567
568     IJavaElement e = getSourceElementAt(position);
569     if (e == this) {
570       return null;
571     } else {
572       return e;
573     }
574   }
575
576   /**
577    * @see IJavaElement
578    */
579   public int getElementType() {
580     return COMPILATION_UNIT;
581   }
582
583   public char[] getFileName() {
584     return getElementName().toCharArray();
585   }
586   /*
587    * @see JavaElement
588    */
589   public IJavaElement getHandleFromMemento(String token, MementoTokenizer memento, WorkingCopyOwner workingCopyOwner) {
590         switch (token.charAt(0)) {
591                 case JEM_COUNT:
592                         return getHandleUpdatingCountFromMemento(memento, workingCopyOwner);
593                 case JEM_IMPORTDECLARATION:
594                         JavaElement container = (JavaElement)getImportContainer();
595                         return container.getHandleFromMemento(token, memento, workingCopyOwner);
596                 case JEM_PACKAGEDECLARATION:
597                         String pkgName = memento.nextToken();
598                         JavaElement pkgDecl = (JavaElement)getPackageDeclaration(pkgName);
599                         return pkgDecl.getHandleFromMemento(memento, workingCopyOwner);
600                 case JEM_TYPE:
601                         String typeName = memento.nextToken();
602                         JavaElement type = (JavaElement)getType(typeName);
603                         return type.getHandleFromMemento(memento, workingCopyOwner);
604         }
605         return null;
606   }
607
608   /**
609    * @see JavaElement#getHandleMementoDelimiter()
610    */
611   protected char getHandleMementoDelimiter() {
612         return JavaElement.JEM_COMPILATIONUNIT;
613   }
614   /**
615    * @see ICompilationUnit#getImport(String)
616    */
617   public IImportDeclaration getImport(String importName) {
618         return new ImportDeclaration((ImportContainer)getImportContainer(), importName);
619   }
620   /**
621    * @see ICompilationUnit#getImportContainer()
622    */
623   public IImportContainer getImportContainer() {
624         return new ImportContainer(this);
625   }
626
627
628   /**
629    * @see ICompilationUnit#getImports()
630    */
631   public IImportDeclaration[] getImports() throws JavaModelException {
632         IImportContainer container= getImportContainer();
633         if (container.exists()) {
634                 IJavaElement[] elements= container.getChildren();
635                 IImportDeclaration[] imprts= new IImportDeclaration[elements.length];
636                 System.arraycopy(elements, 0, imprts, 0, elements.length);
637                 return imprts;
638         } else if (!exists()) {
639                         throw newNotPresentException();
640         } else {
641                 return new IImportDeclaration[0];
642         }
643
644   }
645
646   /**
647    * @see net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit#getMainTypeName()
648    */
649   public char[] getMainTypeName() {
650     String name = getElementName();
651     //remove the .java
652     name = name.substring(0, name.length() - 5);
653     return name.toCharArray();
654   }
655
656   /**
657    * @see IWorkingCopy#getOriginal(IJavaElement)
658    * @deprecated
659    */
660   public IJavaElement getOriginal(IJavaElement workingCopyElement) {
661     // backward compatibility
662     if (!isWorkingCopy())
663       return null;
664     CompilationUnit cu = (CompilationUnit) workingCopyElement.getAncestor(COMPILATION_UNIT);
665     if (cu == null || !this.owner.equals(cu.owner)) {
666       return null;
667     }
668
669     return workingCopyElement.getPrimaryElement();
670   }
671
672   /**
673    * @see IWorkingCopy#getOriginalElement()
674    * @deprecated
675    */
676   public IJavaElement getOriginalElement() {
677     // backward compatibility
678     if (!isWorkingCopy())
679       return null;
680
681     return getPrimaryElement();
682   }
683
684   /*
685    * @see ICompilationUnit#getOwner()
686    */
687   public WorkingCopyOwner getOwner() {
688     return isPrimary() || !isWorkingCopy() ? null : this.owner;
689   }
690
691   /**
692    * @see ICompilationUnit#getPackageDeclaration(String)
693    */
694   public IPackageDeclaration getPackageDeclaration(String name) {
695     return new PackageDeclaration(this, name);
696   }
697
698   /**
699    * @see ICompilationUnit#getPackageDeclarations()
700    */
701   public IPackageDeclaration[] getPackageDeclarations() throws JavaModelException {
702     ArrayList list = getChildrenOfType(PACKAGE_DECLARATION);
703     IPackageDeclaration[] array = new IPackageDeclaration[list.size()];
704     list.toArray(array);
705     return array;
706   }
707
708   /**
709    * @see net.sourceforge.phpdt.internal.compiler.env.ICompilationUnit#getPackageName()
710    */
711   public char[][] getPackageName() {
712     return null;
713   }
714
715   /**
716    * @see IJavaElement#getPath()
717    */
718   public IPath getPath() {
719     PackageFragmentRoot root = this.getPackageFragmentRoot();
720     if (root.isArchive()) {
721       return root.getPath();
722     } else {
723       return this.getParent().getPath().append(this.getElementName());
724     }
725   }
726
727   /*
728    * Returns the per working copy info for the receiver, or null if none exist. Note: the use count of the per working copy info is
729    * NOT incremented.
730    */
731   public JavaModelManager.PerWorkingCopyInfo getPerWorkingCopyInfo() {
732     return JavaModelManager.getJavaModelManager().getPerWorkingCopyInfo(this, false/* don't create */, false/* don't record usage */,
733         null/* no problem requestor needed */);
734   }
735
736   /*
737    * @see ICompilationUnit#getPrimary()
738    */
739   public ICompilationUnit getPrimary() {
740     return (ICompilationUnit) getPrimaryElement(true);
741   }
742
743   /*
744    * @see JavaElement#getPrimaryElement(boolean)
745    */
746   public IJavaElement getPrimaryElement(boolean checkOwner) {
747     if (checkOwner && isPrimary())
748       return this;
749     return new CompilationUnit((PackageFragment) getParent(), getElementName(), DefaultWorkingCopyOwner.PRIMARY);
750   }
751
752   /**
753    * @see IJavaElement#getResource()
754    */
755   public IResource getResource() {
756     PackageFragmentRoot root = this.getPackageFragmentRoot();
757     if (root.isArchive()) {
758       return root.getResource();
759     } else {
760       return ((IContainer) this.getParent().getResource()).getFile(new Path(this.getElementName()));
761     }
762   }
763
764   /**
765    * @see ISourceReference#getSource()
766    */
767   public String getSource() throws JavaModelException {
768     IBuffer buffer = getBuffer();
769     if (buffer == null)
770       return ""; //$NON-NLS-1$
771     return buffer.getContents();
772   }
773
774   /**
775    * @see ISourceReference#getSourceRange()
776    */
777   public ISourceRange getSourceRange() throws JavaModelException {
778     return ((CompilationUnitElementInfo) getElementInfo()).getSourceRange();
779   }
780
781   /**
782    * @see ICompilationUnit#getType(String)
783    */
784   public IType getType(String name) {
785     return new SourceType(this, name);
786   }
787
788   /**
789    * @see ICompilationUnit#getTypes()
790    */
791   public IType[] getTypes() throws JavaModelException {
792     ArrayList list = getChildrenOfType(TYPE);
793     IType[] array = new IType[list.size()];
794     list.toArray(array);
795     return array;
796   }
797
798   /**
799    * @see IJavaElement
800    */
801   public IResource getUnderlyingResource() throws JavaModelException {
802     if (isWorkingCopy() && !isPrimary())
803       return null;
804     return super.getUnderlyingResource();
805   }
806
807   ///**
808   // * @see IWorkingCopy#getSharedWorkingCopy(IProgressMonitor, IBufferFactory, IProblemRequestor)
809   // */
810   //public IJavaElement getSharedWorkingCopy(IProgressMonitor pm, IBufferFactory factory, IProblemRequestor problemRequestor)
811   // throws JavaModelException {
812   //
813   //    // if factory is null, default factory must be used
814   //    if (factory == null) factory = this.getBufferManager().getDefaultBufferFactory();
815   //
816   //    JavaModelManager manager = JavaModelManager.getJavaModelManager();
817   //
818   //    // In order to be shared, working copies have to denote the same compilation unit
819   //    // AND use the same buffer factory.
820   //    // Assuming there is a little set of buffer factories, then use a 2 level Map cache.
821   //    Map sharedWorkingCopies = manager.sharedWorkingCopies;
822   //
823   //    Map perFactoryWorkingCopies = (Map) sharedWorkingCopies.get(factory);
824   //    if (perFactoryWorkingCopies == null){
825   //            perFactoryWorkingCopies = new HashMap();
826   //            sharedWorkingCopies.put(factory, perFactoryWorkingCopies);
827   //    }
828   //    WorkingCopy workingCopy = (WorkingCopy)perFactoryWorkingCopies.get(this);
829   //    if (workingCopy != null) {
830   //            workingCopy.useCount++;
831   //
832   //            if (SHARED_WC_VERBOSE) {
833   //                    System.out.println("Incrementing use count of shared working copy " + workingCopy.toStringWithAncestors()); //$NON-NLS-1$
834   //            }
835   //
836   //            return workingCopy;
837   //    } else {
838   //            CreateWorkingCopyOperation op = new CreateWorkingCopyOperation(this, perFactoryWorkingCopies, factory, problemRequestor);
839   //            runOperation(op, pm);
840   //            return op.getResultElements()[0];
841   //    }
842   //}
843   ///**
844   // * @see IWorkingCopy#getWorkingCopy()
845   // */
846   //public IJavaElement getWorkingCopy() throws JavaModelException {
847   //    return this.getWorkingCopy(null, null, null);
848   //}
849   //
850   ///**
851   // * @see IWorkingCopy#getWorkingCopy(IProgressMonitor, IBufferFactory, IProblemRequestor)
852   // */
853   //public IJavaElement getWorkingCopy(IProgressMonitor pm, IBufferFactory factory, IProblemRequestor problemRequestor) throws
854   // JavaModelException {
855   //    CreateWorkingCopyOperation op = new CreateWorkingCopyOperation(this, null, factory, problemRequestor);
856   //    runOperation(op, pm);
857   //    return op.getResultElements()[0];
858   //}
859   /**
860    * @see IWorkingCopy#getSharedWorkingCopy(IProgressMonitor, IBufferFactory, IProblemRequestor)
861    * @deprecated
862    */
863   public IJavaElement getSharedWorkingCopy(IProgressMonitor pm, IBufferFactory factory, IProblemRequestor problemRequestor)
864       throws JavaModelException {
865
866     // if factory is null, default factory must be used
867     if (factory == null)
868       factory = this.getBufferManager().getDefaultBufferFactory();
869
870     return getWorkingCopy(BufferFactoryWrapper.create(factory), problemRequestor, pm);
871   }
872
873   /**
874    * @see IWorkingCopy#getWorkingCopy()
875    * @deprecated
876    */
877   public IJavaElement getWorkingCopy() throws JavaModelException {
878     return getWorkingCopy(null);
879   }
880
881   /**
882    * @see ICompilationUnit#getWorkingCopy(IProgressMonitor)
883    */
884   public ICompilationUnit getWorkingCopy(IProgressMonitor monitor) throws JavaModelException {
885     return getWorkingCopy(new WorkingCopyOwner() {/* non shared working copy */
886     }, null/* no problem requestor */, monitor);
887   }
888
889   /**
890    * @see IWorkingCopy#getWorkingCopy(IProgressMonitor, IBufferFactory, IProblemRequestor)
891    * @deprecated
892    */
893   public IJavaElement getWorkingCopy(IProgressMonitor monitor, IBufferFactory factory, IProblemRequestor problemRequestor)
894       throws JavaModelException {
895     return getWorkingCopy(BufferFactoryWrapper.create(factory), problemRequestor, monitor);
896   }
897
898   /**
899    * @see ICompilationUnit#getWorkingCopy(WorkingCopyOwner, IProblemRequestor, IProgressMonitor)
900    */
901   public ICompilationUnit getWorkingCopy(WorkingCopyOwner workingCopyOwner, IProblemRequestor problemRequestor,
902       IProgressMonitor monitor) throws JavaModelException {
903     if (!isPrimary())
904       return this;
905
906     JavaModelManager manager = JavaModelManager.getJavaModelManager();
907
908     CompilationUnit workingCopy = new CompilationUnit((PackageFragment) getParent(), getElementName(), workingCopyOwner);
909     JavaModelManager.PerWorkingCopyInfo perWorkingCopyInfo = manager.getPerWorkingCopyInfo(workingCopy, false/* don't create */,
910         true/* record usage */, null/* not used since don't create */);
911     if (perWorkingCopyInfo != null) {
912       return perWorkingCopyInfo.getWorkingCopy(); // return existing handle instead of the one created above
913     }
914     BecomeWorkingCopyOperation op = new BecomeWorkingCopyOperation(workingCopy, problemRequestor);
915     op.runOperation(monitor);
916     return workingCopy;
917   }
918
919   /**
920    * If I am not open, return true to avoid parsing.
921    *
922    * @see IParent#hasChildren()
923    */
924   public boolean hasChildren() throws JavaModelException {
925     //  if (isOpen()) {
926     //          return getChildren().length > 0;
927     //  } else {
928     //          return true;
929     //  }
930     return false;
931   }
932
933   /**
934    * @see Openable#hasBuffer()
935    */
936   protected boolean hasBuffer() {
937     return true;
938   }
939
940   /*
941    * @see ICompilationUnit#hasResourceChanged()
942    */
943   public boolean hasResourceChanged() {
944     if (!isWorkingCopy())
945       return false;
946
947     // if resource got deleted, then #getModificationStamp() will answer IResource.NULL_STAMP, which is always different from the
948     // cached
949     // timestamp
950     Object info = JavaModelManager.getJavaModelManager().getInfo(this);
951     if (info == null)
952       return false;
953     return ((CompilationUnitElementInfo) info).timestamp != getResource().getModificationStamp();
954   }
955
956   /**
957    * @see IWorkingCopy#isBasedOn(IResource)
958    * @deprecated
959    */
960   public boolean isBasedOn(IResource resource) {
961     if (!isWorkingCopy())
962       return false;
963     if (!getResource().equals(resource))
964       return false;
965     return !hasResourceChanged();
966   }
967
968   /**
969    * @see IOpenable#isConsistent()
970    */
971   public boolean isConsistent() {
972     return JavaModelManager.getJavaModelManager().getElementsOutOfSynchWithBuffers().get(this) == null;
973   }
974
975   /**
976    *
977    * @see IOpenable
978    */
979   public boolean isOpen() {
980     Object info = JavaModelManager.getJavaModelManager().getInfo(this);
981     return info != null && ((CompilationUnitElementInfo) info).isOpen();
982   }
983
984   public boolean isPrimary() {
985     return this.owner == DefaultWorkingCopyOwner.PRIMARY;
986   }
987
988   /**
989    * @see Openable#isSourceElement()
990    */
991   protected boolean isSourceElement() {
992     return true;
993   }
994
995   protected boolean isValidCompilationUnit() {
996     IPackageFragmentRoot root = getPackageFragmentRoot();
997     try {
998       if (root.getKind() != IPackageFragmentRoot.K_SOURCE)
999         return false;
1000     } catch (JavaModelException e) {
1001       return false;
1002     }
1003     //  IResource resource = getResource();
1004     //  if (resource != null) {
1005     //          char[][] inclusionPatterns = ((PackageFragmentRoot)root).fullInclusionPatternChars();
1006     //          char[][] exclusionPatterns = ((PackageFragmentRoot)root).fullExclusionPatternChars();
1007     //          if (ProjectPrefUtil.isExcluded(resource, inclusionPatterns, exclusionPatterns)) return false;
1008     //  }
1009     if (!Util.isValidCompilationUnitName(getElementName()))
1010       return false;
1011     return true;
1012   }
1013
1014   /*
1015    * @see ICompilationUnit#isWorkingCopy()
1016    */
1017   public boolean isWorkingCopy() {
1018     // For backward compatibility, non primary working copies are always returning true; in removal
1019     // delta, clients can still check that element was a working copy before being discarded.
1020     return !isPrimary() || getPerWorkingCopyInfo() != null;
1021   }
1022
1023   /**
1024    * @see IOpenable#makeConsistent(IProgressMonitor)
1025    */
1026   public void makeConsistent(IProgressMonitor monitor) throws JavaModelException {
1027     makeConsistent(false/* don't create AST */, 0, monitor);
1028   }
1029
1030   public Object makeConsistent(boolean createAST, int astLevel, IProgressMonitor monitor) throws JavaModelException {
1031     if (isConsistent())
1032       return null;
1033
1034     // create a new info and make it the current info
1035     // (this will remove the info and its children just before storing the new infos)
1036     //  if (createAST) {
1037     //          ASTHolderCUInfo info = new ASTHolderCUInfo();
1038     //          info.astLevel = astLevel;
1039     //          openWhenClosed(info, monitor);
1040     //          net.sourceforge.phpdt.core.dom.CompilationUnit result = info.ast;
1041     //          info.ast = null;
1042     //          return result;
1043     //  } else {
1044     openWhenClosed(createElementInfo(), monitor);
1045     return null;
1046     //  }
1047   }
1048
1049   //public net.sourceforge.phpdt.core.dom.CompilationUnit makeConsistent(boolean createAST, int astLevel, IProgressMonitor monitor)
1050   // throws JavaModelException {
1051   //    if (isConsistent()) return null;
1052   //
1053   //    // create a new info and make it the current info
1054   //    // (this will remove the info and its children just before storing the new infos)
1055   //    if (createAST) {
1056   //            ASTHolderCUInfo info = new ASTHolderCUInfo();
1057   //            info.astLevel = astLevel;
1058   //            openWhenClosed(info, monitor);
1059   //            net.sourceforge.phpdt.core.dom.CompilationUnit result = info.ast;
1060   //            info.ast = null;
1061   //            return result;
1062   //    } else {
1063   //            openWhenClosed(createElementInfo(), monitor);
1064   //            return null;
1065   //    }
1066   //}
1067
1068   /**
1069    * @see ISourceManipulation#move(IJavaElement, IJavaElement, String, boolean, IProgressMonitor)
1070    */
1071   public void move(IJavaElement container, IJavaElement sibling, String rename, boolean force, IProgressMonitor monitor)
1072       throws JavaModelException {
1073     if (container == null) {
1074       throw new IllegalArgumentException(Util.bind("operation.nullContainer")); //$NON-NLS-1$
1075     }
1076     IJavaElement[] elements = new IJavaElement[] { this };
1077     IJavaElement[] containers = new IJavaElement[] { container };
1078
1079     String[] renamings = null;
1080     if (rename != null) {
1081       renamings = new String[] { rename };
1082     }
1083     getJavaModel().move(elements, containers, null, renamings, force, monitor);
1084   }
1085
1086   ///**
1087   // * @see Openable#openBuffer(IProgressMonitor)
1088   // */
1089   //protected IBuffer openBuffer(IProgressMonitor pm) throws JavaModelException {
1090   //
1091   //    // create buffer - compilation units only use default buffer factory
1092   //    BufferManager bufManager = getBufferManager();
1093   //    IBuffer buffer = getBufferFactory().createBuffer(this);
1094   //    if (buffer == null) return null;
1095   //
1096   //    // set the buffer source
1097   //    if (buffer.getCharacters() == null){
1098   //            IFile file = (IFile)this.getResource();
1099   //            if (file == null || !file.exists()) throw newNotPresentException();
1100   //            buffer.setContents(ProjectPrefUtil.getResourceContentsAsCharArray(file));
1101   //    }
1102   //
1103   //    // add buffer to buffer cache
1104   //    bufManager.addBuffer(buffer);
1105   //
1106   //    // listen to buffer changes
1107   //    buffer.addBufferChangedListener(this);
1108   //
1109   //    return buffer;
1110   //}
1111   /**
1112    * @see Openable#openBuffer(IProgressMonitor, Object)
1113    */
1114   protected IBuffer openBuffer(IProgressMonitor pm, Object info) throws JavaModelException {
1115
1116     // create buffer
1117     boolean isWorkingCopy = isWorkingCopy();
1118     IBuffer buffer = isWorkingCopy ? this.owner.createBuffer(this) : BufferManager.getDefaultBufferManager().createBuffer(this);
1119     if (buffer == null)
1120       return null;
1121
1122     // set the buffer source
1123     if (buffer.getCharacters() == null) {
1124       if (isWorkingCopy) {
1125         ICompilationUnit original;
1126         if (!isPrimary()
1127             && (original = new CompilationUnit((PackageFragment) getParent(), getElementName(), DefaultWorkingCopyOwner.PRIMARY))
1128                 .isOpen()) {
1129           buffer.setContents(original.getSource());
1130         } else {
1131           IFile file = (IFile) getResource();
1132           if (file == null || !file.exists()) {
1133             // initialize buffer with empty contents
1134             buffer.setContents(CharOperation.NO_CHAR);
1135           } else {
1136             buffer.setContents(Util.getResourceContentsAsCharArray(file));
1137           }
1138         }
1139       } else {
1140         IFile file = (IFile) this.getResource();
1141         if (file == null || !file.exists())
1142           throw newNotPresentException();
1143         buffer.setContents(Util.getResourceContentsAsCharArray(file));
1144       }
1145     }
1146
1147     // add buffer to buffer cache
1148     BufferManager bufManager = getBufferManager();
1149     bufManager.addBuffer(buffer);
1150
1151     // listen to buffer changes
1152     buffer.addBufferChangedListener(this);
1153
1154     return buffer;
1155   }
1156
1157   /*
1158    * @see Openable#openParent
1159    */
1160   protected void openParent(Object childInfo, HashMap newElements, IProgressMonitor pm) throws JavaModelException {
1161     try {
1162       super.openParent(childInfo, newElements, pm);
1163     } catch (JavaModelException e) {
1164       // allow parent to not exist for working copies defined outside classpath
1165       if (!isWorkingCopy() && !e.isDoesNotExist()) {
1166         throw e;
1167       }
1168     }
1169   }
1170
1171   /**
1172    * @see ICompilationUnit#reconcile()
1173    * @deprecated
1174    */
1175   public IMarker[] reconcile() throws JavaModelException {
1176     reconcile(NO_AST, false/* don't force problem detection */, null/* use primary owner */, null/* no progress monitor */);
1177     return null;
1178   }
1179
1180   /**
1181    * @see ICompilationUnit#reconcile(int, boolean, WorkingCopyOwner, IProgressMonitor)
1182    */
1183   public void reconcile(boolean forceProblemDetection, IProgressMonitor monitor) throws JavaModelException {
1184     reconcile(NO_AST, forceProblemDetection, null/* use primary owner */, monitor);
1185   }
1186
1187   /**
1188    * @see ICompilationUnit#reconcile(int, boolean, WorkingCopyOwner, IProgressMonitor)
1189    * @since 3.0
1190    */
1191   //public net.sourceforge.phpdt.core.dom.CompilationUnit reconcile(
1192   public Object reconcile(int astLevel, boolean forceProblemDetection, WorkingCopyOwner workingCopyOwner, IProgressMonitor monitor)
1193       throws JavaModelException {
1194
1195     if (!isWorkingCopy())
1196       return null; // Reconciling is not supported on non working copies
1197     if (workingCopyOwner == null)
1198       workingCopyOwner = DefaultWorkingCopyOwner.PRIMARY;
1199
1200     boolean createAST = false;
1201     //  if (astLevel == AST.JLS2) {
1202     //          // client asking for level 2 AST; these are supported
1203     //          createAST = true;
1204     //  } else if (astLevel == AST.JLS3) {
1205     //          // client asking for level 3 ASTs; these are not supported
1206     //          // TODO (jerome) - these should also be supported in 1.5 stream
1207     //          createAST = false;
1208     //  } else {
1209     //          // client asking for no AST (0) or unknown ast level
1210     //          // either way, request denied
1211     //          createAST = false;
1212     //  }
1213     ReconcileWorkingCopyOperation op = new ReconcileWorkingCopyOperation(this, createAST, astLevel, forceProblemDetection,
1214         workingCopyOwner);
1215     op.runOperation(monitor);
1216     //  return op.ast;
1217     return null;
1218   }
1219
1220   /**
1221    * @see ISourceManipulation#rename(String, boolean, IProgressMonitor)
1222    */
1223   public void rename(String name, boolean force, IProgressMonitor monitor) throws JavaModelException {
1224     if (name == null) {
1225       throw new IllegalArgumentException(Util.bind("operation.nullName")); //$NON-NLS-1$
1226     }
1227     IJavaElement[] elements = new IJavaElement[] { this };
1228     IJavaElement[] dests = new IJavaElement[] { this.getParent() };
1229     String[] renamings = new String[] { name };
1230     getJavaModel().rename(elements, dests, renamings, force, monitor);
1231   }
1232
1233   /*
1234    * @see ICompilationUnit
1235    */
1236   public void restore() throws JavaModelException {
1237
1238     if (!isWorkingCopy())
1239       return;
1240
1241     CompilationUnit original = (CompilationUnit) getOriginalElement();
1242     IBuffer buffer = this.getBuffer();
1243     if (buffer == null)
1244       return;
1245     buffer.setContents(original.getContents());
1246     updateTimeStamp(original);
1247     makeConsistent(null);
1248   }
1249
1250   /**
1251    * @see ICodeAssist#codeComplete(int, ICodeCompletionRequestor)
1252    * @deprecated - use codeComplete(int, ICompletionRequestor)
1253    */
1254   //public void codeComplete(int offset, final ICodeCompletionRequestor requestor) throws JavaModelException {
1255   //
1256   //    if (requestor == null){
1257   //            codeComplete(offset, (ICompletionRequestor)null);
1258   //            return;
1259   //    }
1260   //    codeComplete(
1261   //            offset,
1262   //            new ICompletionRequestor(){
1263   //                    public void acceptAnonymousType(char[] superTypePackageName,char[] superTypeName,char[][] parameterPackageNames,char[][]
1264   // parameterTypeNames,char[][] parameterNames,char[] completionName,int modifiers,int completionStart,int completionEnd, int
1265   // relevance){
1266   //                    }
1267   //                    public void acceptClass(char[] packageName, char[] className, char[] completionName, int modifiers, int completionStart, int
1268   // completionEnd, int relevance) {
1269   //                            requestor.acceptClass(packageName, className, completionName, modifiers, completionStart, completionEnd);
1270   //                    }
1271   //                    public void acceptError(IProblem error) {
1272   //                            if (true) return; // was disabled in 1.0
1273   //
1274   //                            try {
1275   //                                    IMarker marker = ResourcesPlugin.getWorkspace().getRoot().createMarker(IJavaModelMarker.TRANSIENT_PROBLEM);
1276   //                                    marker.setAttribute(IJavaModelMarker.ID, error.getID());
1277   //                                    marker.setAttribute(IMarker.CHAR_START, error.getSourceStart());
1278   //                                    marker.setAttribute(IMarker.CHAR_END, error.getSourceEnd() + 1);
1279   //                                    marker.setAttribute(IMarker.LINE_NUMBER, error.getSourceLineNumber());
1280   //                                    marker.setAttribute(IMarker.MESSAGE, error.getMessage());
1281   //                                    marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
1282   //                                    requestor.acceptError(marker);
1283   //                            } catch(CoreException e){
1284   //                            }
1285   //                    }
1286   //                    public void acceptField(char[] declaringTypePackageName, char[] declaringTypeName, char[] name, char[] typePackageName, char[]
1287   // typeName, char[] completionName, int modifiers, int completionStart, int completionEnd, int relevance) {
1288   //                            requestor.acceptField(declaringTypePackageName, declaringTypeName, name, typePackageName, typeName, completionName, modifiers,
1289   // completionStart, completionEnd);
1290   //                    }
1291   //                    public void acceptInterface(char[] packageName,char[] interfaceName,char[] completionName,int modifiers,int completionStart,int
1292   // completionEnd, int relevance) {
1293   //                            requestor.acceptInterface(packageName, interfaceName, completionName, modifiers, completionStart, completionEnd);
1294   //                    }
1295   //                    public void acceptKeyword(char[] keywordName,int completionStart,int completionEnd, int relevance){
1296   //                            requestor.acceptKeyword(keywordName, completionStart, completionEnd);
1297   //                    }
1298   //                    public void acceptLabel(char[] labelName,int completionStart,int completionEnd, int relevance){
1299   //                            requestor.acceptLabel(labelName, completionStart, completionEnd);
1300   //                    }
1301   //                    public void acceptLocalVariable(char[] name,char[] typePackageName,char[] typeName,int modifiers,int completionStart,int
1302   // completionEnd, int relevance){
1303   //                            // ignore
1304   //                    }
1305   //                    public void acceptMethod(char[] declaringTypePackageName,char[] declaringTypeName,char[] selector,char[][]
1306   // parameterPackageNames,char[][] parameterTypeNames,char[][] parameterNames,char[] returnTypePackageName,char[]
1307   // returnTypeName,char[] completionName,int modifiers,int completionStart,int completionEnd, int relevance){
1308   //                            // skip parameter names
1309   //                            requestor.acceptMethod(declaringTypePackageName, declaringTypeName, selector, parameterPackageNames, parameterTypeNames,
1310   // returnTypePackageName, returnTypeName, completionName, modifiers, completionStart, completionEnd);
1311   //                    }
1312   //                    public void acceptMethodDeclaration(char[] declaringTypePackageName,char[] declaringTypeName,char[] selector,char[][]
1313   // parameterPackageNames,char[][] parameterTypeNames,char[][] parameterNames,char[] returnTypePackageName,char[]
1314   // returnTypeName,char[] completionName,int modifiers,int completionStart,int completionEnd, int relevance){
1315   //                            // ignore
1316   //                    }
1317   //                    public void acceptModifier(char[] modifierName,int completionStart,int completionEnd, int relevance){
1318   //                            requestor.acceptModifier(modifierName, completionStart, completionEnd);
1319   //                    }
1320   //                    public void acceptPackage(char[] packageName,char[] completionName,int completionStart,int completionEnd, int relevance){
1321   //                            requestor.acceptPackage(packageName, completionName, completionStart, completionEnd);
1322   //                    }
1323   //                    public void acceptType(char[] packageName,char[] typeName,char[] completionName,int completionStart,int completionEnd, int
1324   // relevance){
1325   //                            requestor.acceptType(packageName, typeName, completionName, completionStart, completionEnd);
1326   //                    }
1327   //                    public void acceptVariableName(char[] typePackageName,char[] typeName,char[] name,char[] completionName,int completionStart,int
1328   // completionEnd, int relevance){
1329   //                            // ignore
1330   //                    }
1331   //            });
1332   //}
1333   ///**
1334   // * @see JavaElement#rootedAt(IJavaProject)
1335   // */
1336   //public IJavaElement rootedAt(IJavaProject project) {
1337   //    return
1338   //            new CompilationUnit(
1339   //                    (IPackageFragment)((JavaElement)parent).rootedAt(project),
1340   //                    name);
1341   //}
1342   /*
1343    * Assume that this is a working copy
1344    */
1345   protected void updateTimeStamp(CompilationUnit original) throws JavaModelException {
1346     long timeStamp = ((IFile) original.getResource()).getModificationStamp();
1347     if (timeStamp == IResource.NULL_STAMP) {
1348       throw new JavaModelException(new JavaModelStatus(IJavaModelStatusConstants.INVALID_RESOURCE));
1349     }
1350     ((CompilationUnitElementInfo) getElementInfo()).timestamp = timeStamp;
1351   }
1352 }