Added support for breakpoint in external source.
Improved the breakpoint location verifier process.
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ActionMessages.properties b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ActionMessages.properties
index 40a4a88..d46d046 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ActionMessages.properties
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ActionMessages.properties
@@ -143,3 +143,6 @@
ObjectActionDelegate.Unable_to_display_type_hierarchy._The_selected_source_element_is_not_contained_in_the_workspace._1=Unable to display type hierarchy. The selected source element is not contained in the workspace.
ManageBreakpointRulerAction.Breakpoints_can_only_be_created_within_the_type_associated_with_the_editor__{0}._1=Breakpoints can only be created within the type associated with the editor: {0}.
+ManageBreakpointActionDelegate.breakpoint_location=Breakpoint location validation
+ManageBreakpointActionDelegate.not_valid_location=Breakpoint cannot be set at the given position
+ManageBreakpointActionDelegate.breakpoint_set=Breakpoint set
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/BreakpointLocationVerifierJob.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/BreakpointLocationVerifierJob.java
new file mode 100644
index 0000000..b157eb4
--- /dev/null
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/BreakpointLocationVerifierJob.java
@@ -0,0 +1,178 @@
+/*******************************************************************************
+ * Copyright (c) 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.debug.ui.actions;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.runtime.jobs.Job;
+import org.eclipse.debug.core.DebugPlugin;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.dom.AST;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.debug.core.IJavaLineBreakpoint;
+import org.eclipse.jdt.debug.core.JDIDebugModel;
+import org.eclipse.jdt.internal.debug.ui.BreakpointUtils;
+import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.IRegion;
+import org.eclipse.swt.widgets.Display;
+
+/**
+ * Job used to verify the position of a breakpoint
+ */
+public class BreakpointLocationVerifierJob extends Job {
+
+ /**
+ * The document which contains the code source.
+ */
+ private IDocument fDocument;
+
+ /**
+ * The offset in the document where the breakpoint has been requested
+ */
+ private int fOffset;
+
+ /**
+ * The temporary breakpoint that has been set. Can be <code>null</code> if the callee was not able
+ * to check if a breakpoint was already set at this position.
+ */
+ private IJavaLineBreakpoint fBreakpoint;
+
+ /**
+ * The number of the line where the breakpoint has been requested.
+ */
+ private int fLineNumber;
+
+ /**
+ * The qualified type name of the class where the temporary breakpoint as been set.
+ * Can be <code>null</code> if fBreakpoint is null.
+ */
+ private String fTypeName;
+
+ /**
+ * The type in which should be set the breakpoint.
+ */
+ private IType fType;
+
+ /**
+ * The resource in which should be set the breakpoint.
+ */
+ private IResource fResource;
+
+ public BreakpointLocationVerifierJob(IDocument document, int offset, IJavaLineBreakpoint breakpoint, int lineNumber, String typeName, IType type, IResource resource) {
+ super(ActionMessages.getString("ManageBreakpointActionDelegate.breakpoint_location")); //$NON-NLS-1$
+ fDocument= document;
+ fOffset= offset;
+ fBreakpoint= breakpoint;
+ fLineNumber= lineNumber;
+ fTypeName= typeName;
+ fType= type;
+ fResource= resource;
+ }
+
+ public IStatus run(IProgressMonitor monitor) {
+ CompilationUnit compilationUnit= AST.parseCompilationUnit(fDocument.get().toCharArray());
+ ValidBreakpointLocationLocator locator= new ValidBreakpointLocationLocator(compilationUnit, fOffset);
+ compilationUnit.accept(locator);
+ int lineNumber= locator.getValidLocation();
+ String typeName= locator.getFullyQualifiedTypeName();
+
+ try {
+ if (lineNumber == -1) {
+ // cannot found a valid line
+ Display.getCurrent().beep();
+ if (fBreakpoint != null) {
+ DebugPlugin.getDefault().getBreakpointManager().removeBreakpoint(fBreakpoint, true);
+ }
+ return new Status(IStatus.ERROR, JDIDebugUIPlugin.getUniqueIdentifier(), IStatus.ERROR, ActionMessages.getString("ManageBreakpointActionDelegate.not_valid_location"), null); //$NON-NLS-1$
+ }
+ boolean differentLineNumber= lineNumber != fLineNumber;
+ IJavaLineBreakpoint breakpoint= JDIDebugModel.lineBreakpointExists(typeName, lineNumber);
+ boolean breakpointExist= breakpoint != null;
+ if (fBreakpoint == null) {
+ if (breakpointExist) {
+ if (differentLineNumber) {
+ // There is already a breakpoint on the valid line.
+ beep();
+ return new Status(IStatus.ERROR, JDIDebugUIPlugin.getUniqueIdentifier(), IStatus.ERROR, ActionMessages.getString("ManageBreakpointActionDelegate.not_valid_location"), null); //$NON-NLS-1$
+ } else {
+ // There is already a breakpoint on the valid line, but it's also the requested line.
+ // Removing the existing breakpoint.
+ DebugPlugin.getDefault().getBreakpointManager().removeBreakpoint(breakpoint, true);
+ return new Status(IStatus.OK, JDIDebugUIPlugin.getUniqueIdentifier(), IStatus.ERROR, "Breakpoint removed.", null); //$NON-NLS-1$
+ }
+ }
+ createNewBreakpoint(lineNumber, typeName);
+ return new Status(IStatus.OK, JDIDebugUIPlugin.getUniqueIdentifier(), IStatus.OK, ActionMessages.getString("ManageBreakpointActionDelegate.breakpoint_set"), null); //$NON-NLS-1$
+ } else {
+ if (differentLineNumber) {
+ if (breakpointExist) {
+ // there is already a breakpoint on the valid line.
+ beep();
+ DebugPlugin.getDefault().getBreakpointManager().removeBreakpoint(fBreakpoint, true);
+ return new Status(IStatus.ERROR, JDIDebugUIPlugin.getUniqueIdentifier(), IStatus.ERROR, ActionMessages.getString("ManageBreakpointActionDelegate.not_valid_location"), null); //$NON-NLS-1$
+ }
+ replaceBreakpoint(lineNumber, typeName);
+ return new Status(IStatus.WARNING, JDIDebugUIPlugin.getUniqueIdentifier(), IStatus.WARNING, "The breakpoint has been moved to a valid position.", null); //$NON-NLS-1$
+ }
+ if (!typeName.equals(fTypeName)) {
+ replaceBreakpoint(lineNumber, typeName);
+ return new Status(IStatus.WARNING, JDIDebugUIPlugin.getUniqueIdentifier(), IStatus.WARNING, "The breakpoint has been set to the right type.", null); //$NON-NLS-1$
+ }
+ }
+ } catch (CoreException e) {
+ JDIDebugUIPlugin.log(e);
+ }
+ return new Status(IStatus.OK, JDIDebugUIPlugin.getUniqueIdentifier(), IStatus.OK, ActionMessages.getString("ManageBreakpointActionDelegate.breakpoint_set"), null); //$NON-NLS-1$
+ }
+
+ /**
+ * Remove the temporary breakpoint and create a new breakpoint at the right position.
+ */
+ private void replaceBreakpoint(int lineNumber, String typeName) throws CoreException {
+ createNewBreakpoint(lineNumber, typeName);
+ DebugPlugin.getDefault().getBreakpointManager().removeBreakpoint(fBreakpoint, true);
+ }
+
+ /**
+ * Create a new breakpoint at the right position.
+ */
+ private void createNewBreakpoint(int lineNumber, String typeName) throws CoreException {
+ Map newAttributes = new HashMap(10);
+ if (fType != null) {
+ try {
+ IRegion line= fDocument.getLineInformation(lineNumber - 1);
+ int start= line.getOffset();
+ int end= start + line.getLength() - 1;
+ BreakpointUtils.addJavaBreakpointAttributesWithMemberDetails(newAttributes, fType, start, end);
+ } catch (BadLocationException ble) {
+ JDIDebugUIPlugin.log(ble);
+ }
+ }
+ JDIDebugModel.createLineBreakpoint(fResource, typeName, lineNumber, -1, -1, 0, true, newAttributes);
+ }
+
+ private void beep() {
+ JDIDebugUIPlugin.getStandardDisplay().asyncExec(new Runnable() {
+ public void run() {
+ Display.getCurrent().beep();
+ }
+ });
+ }
+
+}
\ No newline at end of file
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ManageBreakpointActionDelegate.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ManageBreakpointActionDelegate.java
index 4b28c1c..bd244b4 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ManageBreakpointActionDelegate.java
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ManageBreakpointActionDelegate.java
@@ -11,11 +11,15 @@
package org.eclipse.jdt.internal.debug.ui.actions;
+import java.text.MessageFormat;
import java.util.HashMap;
import java.util.Map;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.DebugPlugin;
+import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.IType;
@@ -28,14 +32,17 @@
import org.eclipse.jdt.internal.debug.ui.snippeteditor.JavaSnippetEditor;
import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.text.BadLocationException;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.ITextSelection;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
+import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IFileEditorInput;
import org.eclipse.ui.IPartListener;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPart;
@@ -65,7 +72,8 @@
*/
protected void manageBreakpoint(IEditorInput editorInput) {
ISelectionProvider sp= getTextEditor().getSelectionProvider();
- if (sp == null || getType() == null) {
+ IType type = getType();
+ if (sp == null) {
report(ActionMessages.getString("ManageBreakpointActionDelegate.No_Breakpoint")); //$NON-NLS-1$
return;
}
@@ -73,28 +81,65 @@
ISelection selection= sp.getSelection();
if (selection instanceof ITextSelection) {
IDocument document= getTextEditor().getDocumentProvider().getDocument(editorInput);
- BreakpointLocationVerifier bv = new BreakpointLocationVerifier();
- int lineNumber = bv.getValidBreakpointLocation(document, ((ITextSelection)selection).getStartLine());
- if (lineNumber > -1) {
- try {
- IJavaLineBreakpoint breakpoint= JDIDebugModel.lineBreakpointExists(getType().getFullyQualifiedName(), lineNumber);
- if (breakpoint != null) {
- DebugPlugin.getDefault().getBreakpointManager().removeBreakpoint(breakpoint, true);
- } else {
- try {
- IRegion line= document.getLineInformation(lineNumber - 1);
- Map attributes = new HashMap(10);
- int start= line.getOffset();
- int end= start + line.getLength() - 1;
- BreakpointUtils.addJavaBreakpointAttributesWithMemberDetails(attributes, getType(), start, end);
- JDIDebugModel.createLineBreakpoint(BreakpointUtils.getBreakpointResource(getType()), getType().getFullyQualifiedName(), lineNumber, -1, -1, 0, true, attributes);
- } catch (BadLocationException ble) {
- JDIDebugUIPlugin.log(ble);
+
+ int lineNumber= ((ITextSelection)selection).getStartLine() + 1;
+
+
+ int offset= ((ITextSelection)selection).getOffset();
+ try {
+ if (type == null) {
+ IClassFile classFile= (IClassFile)editorInput.getAdapter(IClassFile.class);
+ if (classFile != null) {
+ type= classFile.getType();
+ // bug 34856 - if this is an inner type, ensure the breakpoint is not
+ // being added to the outer type
+ if (type.getDeclaringType() != null) {
+ ISourceRange sourceRange= type.getSourceRange();
+ int start= sourceRange.getOffset();
+ int end= start + sourceRange.getLength();
+ if (offset < start || offset > end) {
+ // not in the inner type
+ IStatusLineManager manager= getTextEditor().getEditorSite().getActionBars().getStatusLineManager();
+ manager.setErrorMessage(MessageFormat.format(ActionMessages.getString("ManageBreakpointRulerAction.Breakpoints_can_only_be_created_within_the_type_associated_with_the_editor__{0}._1"), new String[] { type.getTypeQualifiedName()})); //$NON-NLS-1$
+ Display.getCurrent().beep();
+ return;
+ }
}
}
- } catch (CoreException ce) {
- ExceptionHandler.handle(ce, ActionMessages.getString("ManageBreakpointActionDelegate.error.title1"), ActionMessages.getString("ManageBreakpointActionDelegate.error.message1")); //$NON-NLS-1$ //$NON-NLS-2$
}
+
+ String typeName= null;
+ IResource resource;
+ IJavaLineBreakpoint breakpoint= null;
+ if (type == null) {
+ if (editorInput instanceof IFileEditorInput) {
+ resource= ((IFileEditorInput)editorInput).getFile();
+ } else {
+ resource= ResourcesPlugin.getWorkspace().getRoot();
+ }
+ } else {
+ typeName= type.getFullyQualifiedName();
+ IJavaLineBreakpoint existingBreakpoint= JDIDebugModel.lineBreakpointExists(typeName, lineNumber);
+ if (existingBreakpoint != null) {
+ DebugPlugin.getDefault().getBreakpointManager().removeBreakpoint(existingBreakpoint, true);
+ return;
+ }
+ resource= BreakpointUtils.getBreakpointResource(type);
+ Map attributes = new HashMap(10);
+ try {
+ IRegion line= document.getLineInformation(lineNumber - 1);
+ int start= line.getOffset();
+ int end= start + line.getLength() - 1;
+ BreakpointUtils.addJavaBreakpointAttributesWithMemberDetails(attributes, type, start, end);
+ } catch (BadLocationException ble) {
+ JDIDebugUIPlugin.log(ble);
+ }
+ breakpoint= JDIDebugModel.createLineBreakpoint(resource, typeName, lineNumber, -1, -1, 0, true, attributes);
+ }
+ new BreakpointLocationVerifierJob(document, offset, breakpoint, lineNumber, typeName, type, resource).schedule();
+ } catch (CoreException ce) {
+ ExceptionHandler.handle(ce, ActionMessages.getString("ManageBreakpointActionDelegate.error.title1"), ActionMessages.getString("ManageBreakpointActionDelegate.error.message1")); //$NON-NLS-1$ //$NON-NLS-2$
+ return;
}
}
}
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ManageBreakpointRulerAction.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ManageBreakpointRulerAction.java
index 274a4e2..921c44f 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ManageBreakpointRulerAction.java
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ManageBreakpointRulerAction.java
@@ -35,6 +35,7 @@
import org.eclipse.jdt.core.IMember;
import org.eclipse.jdt.core.ISourceRange;
import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.debug.core.IJavaLineBreakpoint;
import org.eclipse.jdt.debug.core.JDIDebugModel;
import org.eclipse.jdt.internal.debug.ui.BreakpointUtils;
import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
@@ -213,64 +214,70 @@
IEditorInput editorInput= getTextEditor().getEditorInput();
- IDocument document= getDocument();
- int rulerLine= getVerticalRulerInfo().getLineOfLastMouseButtonActivity();
-
try {
- BreakpointLocationVerifier bv = new BreakpointLocationVerifier();
- int lineNumber = bv.getValidBreakpointLocation(document, rulerLine);
- if (lineNumber > 0) {
-
- IRegion line= document.getLineInformation(lineNumber - 1);
-
- IType type = null;
- IClassFile classFile= (IClassFile) editorInput.getAdapter(IClassFile.class);
- if (classFile != null) {
- type= classFile.getType();
- // bug 34856 - if this is an inner type, ensure the breakpoint is not
- // being added to the outer type
- if (type.getDeclaringType() != null) {
- ISourceRange sourceRange = type.getSourceRange();
- int offset = line.getOffset();
- int start = sourceRange.getOffset();
- int end = start + sourceRange.getLength();
- if (offset < start || offset > end) {
- // not in the inner type
- IStatusLineManager manager = getTextEditor().getEditorSite().getActionBars().getStatusLineManager();
- manager.setErrorMessage(MessageFormat.format(ActionMessages.getString("ManageBreakpointRulerAction.Breakpoints_can_only_be_created_within_the_type_associated_with_the_editor__{0}._1"), new String[]{type.getTypeQualifiedName()})); //$NON-NLS-1$
- Display.getCurrent().beep();
- return;
- }
- }
- } else if (editorInput instanceof IFileEditorInput) {
- IWorkingCopyManager manager= JavaUI.getWorkingCopyManager();
- ICompilationUnit unit= manager.getWorkingCopy(editorInput);
- if (unit != null) {
- synchronized (unit) {
- unit.reconcile();
- }
- IJavaElement e = unit.getElementAt(line.getOffset());
- if (e instanceof IType) {
- type= (IType)e;
- } else if (e instanceof IMember) {
- type= ((IMember)e).getDeclaringType();
- }
+ IDocument document= getDocument();
+ IRegion line= document.getLineInformation(getVerticalRulerInfo().getLineOfLastMouseButtonActivity());
+
+ IType type= null;
+ IClassFile classFile= (IClassFile)editorInput.getAdapter(IClassFile.class);
+ if (classFile != null) {
+ type= classFile.getType();
+ // bug 34856 - if this is an inner type, ensure the breakpoint is not
+ // being added to the outer type
+ if (type.getDeclaringType() != null) {
+ ISourceRange sourceRange = type.getSourceRange();
+ int offset = line.getOffset();
+ int start = sourceRange.getOffset();
+ int end = start + sourceRange.getLength();
+ if (offset < start || offset > end) {
+ // not in the inner type
+ IStatusLineManager manager = getTextEditor().getEditorSite().getActionBars().getStatusLineManager();
+ manager.setErrorMessage(MessageFormat.format(ActionMessages.getString("ManageBreakpointRulerAction.Breakpoints_can_only_be_created_within_the_type_associated_with_the_editor__{0}._1"), new String[]{type.getTypeQualifiedName()})); //$NON-NLS-1$
+ Display.getCurrent().beep();
+ return;
}
}
-
- if (type != null) {
- IJavaProject project= type.getJavaProject();
- if (type.exists() && project != null && project.isOnClasspath(type)) {
- if (JDIDebugModel.lineBreakpointExists(type.getFullyQualifiedName(),lineNumber) == null) {
- Map attributes = new HashMap(10);
- int start= line.getOffset();
- int end= start + line.getLength() - 1;
- BreakpointUtils.addJavaBreakpointAttributesWithMemberDetails(attributes, type, start, end);
- JDIDebugModel.createLineBreakpoint(getBreakpointResource(type), type.getFullyQualifiedName(), lineNumber, -1, -1, 0, true, attributes);
- }
+ } else if (editorInput instanceof IFileEditorInput) {
+ IWorkingCopyManager manager= JavaUI.getWorkingCopyManager();
+ ICompilationUnit unit= manager.getWorkingCopy(editorInput);
+ if (unit != null) {
+ synchronized (unit) {
+ unit.reconcile();
+ }
+ IJavaElement e= unit.getElementAt(line.getOffset());
+ if (e instanceof IType) {
+ type= (IType)e;
+ } else if (e instanceof IMember) {
+ type= ((IMember)e).getDeclaringType();
}
}
}
+
+ Map attributes= new HashMap(10);
+ IResource resource;
+ String typeName= null;
+ int lineNumber= getVerticalRulerInfo().getLineOfLastMouseButtonActivity();
+ IJavaLineBreakpoint breakpoint= null;
+ if (type == null) {
+ if (editorInput instanceof IFileEditorInput) {
+ resource= ((IFileEditorInput)editorInput).getFile();
+ } else {
+ resource= ResourcesPlugin.getWorkspace().getRoot();
+ }
+ } else {
+ IJavaProject project= type.getJavaProject();
+ typeName= type.getFullyQualifiedName();
+ if (type.exists() && project != null && project.isOnClasspath(type)) {
+ if (JDIDebugModel.lineBreakpointExists(typeName, lineNumber) == null) {
+ int start= line.getOffset();
+ int end= start + line.getLength() - 1;
+ BreakpointUtils.addJavaBreakpointAttributesWithMemberDetails(attributes, type, start, end);
+ }
+ }
+ resource= BreakpointUtils.getBreakpointResource(type);
+ breakpoint= JDIDebugModel.createLineBreakpoint(resource, typeName, lineNumber, -1, -1, 0, true, attributes);
+ }
+ new BreakpointLocationVerifierJob(document, line.getOffset(), breakpoint, lineNumber, typeName, type, resource).schedule();
} catch (DebugException e) {
JDIDebugUIPlugin.errorDialog(ActionMessages.getString("ManageBreakpointRulerAction.error.adding.message1"), e); //$NON-NLS-1$
} catch (CoreException e) {
@@ -293,27 +300,4 @@
}
}
- /**
- * Returns the resource on which a breakpoint marker should
- * be created for the given member. The resource returned is the
- * associated file, or project in the case of a class file in
- * a jar.
- *
- * @param member member in which a breakpoint is being created
- * @return resource the resource on which a breakpoint marker
- * should be created
- * @exception CoreException if an exception occurs accessing the
- * underlying resource or Java model elements
- */
- public IResource getBreakpointResource(IMember member) throws CoreException {
- ICompilationUnit cu = member.getCompilationUnit();
- if (cu != null && cu.isWorkingCopy()) {
- member = (IMember)cu.getOriginal(member);
- }
- IResource res = member.getUnderlyingResource();
- if (res == null) {
- res = member.getJavaProject().getProject();
- }
- return res;
- }
}
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ValidBreakpointLocationLocator.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ValidBreakpointLocationLocator.java
new file mode 100644
index 0000000..7dd150a
--- /dev/null
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/actions/ValidBreakpointLocationLocator.java
@@ -0,0 +1,637 @@
+/*******************************************************************************
+ * Copyright (c) 2003 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Common Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/cpl-v10.html
+ *
+ * Contributors:
+ * IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.jdt.internal.debug.ui.actions;
+
+import java.util.Iterator;
+import java.util.List;
+
+import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
+import org.eclipse.jdt.core.dom.ArrayAccess;
+import org.eclipse.jdt.core.dom.ArrayCreation;
+import org.eclipse.jdt.core.dom.ArrayInitializer;
+import org.eclipse.jdt.core.dom.ArrayType;
+import org.eclipse.jdt.core.dom.AssertStatement;
+import org.eclipse.jdt.core.dom.Assignment;
+import org.eclipse.jdt.core.dom.Block;
+import org.eclipse.jdt.core.dom.BodyDeclaration;
+import org.eclipse.jdt.core.dom.BooleanLiteral;
+import org.eclipse.jdt.core.dom.BreakStatement;
+import org.eclipse.jdt.core.dom.CastExpression;
+import org.eclipse.jdt.core.dom.CatchClause;
+import org.eclipse.jdt.core.dom.CharacterLiteral;
+import org.eclipse.jdt.core.dom.ClassInstanceCreation;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jdt.core.dom.ConditionalExpression;
+import org.eclipse.jdt.core.dom.ConstructorInvocation;
+import org.eclipse.jdt.core.dom.ContinueStatement;
+import org.eclipse.jdt.core.dom.DoStatement;
+import org.eclipse.jdt.core.dom.EmptyStatement;
+import org.eclipse.jdt.core.dom.ExpressionStatement;
+import org.eclipse.jdt.core.dom.FieldAccess;
+import org.eclipse.jdt.core.dom.FieldDeclaration;
+import org.eclipse.jdt.core.dom.ForStatement;
+import org.eclipse.jdt.core.dom.IfStatement;
+import org.eclipse.jdt.core.dom.ImportDeclaration;
+import org.eclipse.jdt.core.dom.InfixExpression;
+import org.eclipse.jdt.core.dom.Initializer;
+import org.eclipse.jdt.core.dom.InstanceofExpression;
+import org.eclipse.jdt.core.dom.Javadoc;
+import org.eclipse.jdt.core.dom.LabeledStatement;
+import org.eclipse.jdt.core.dom.MethodDeclaration;
+import org.eclipse.jdt.core.dom.MethodInvocation;
+import org.eclipse.jdt.core.dom.Name;
+import org.eclipse.jdt.core.dom.NullLiteral;
+import org.eclipse.jdt.core.dom.NumberLiteral;
+import org.eclipse.jdt.core.dom.PackageDeclaration;
+import org.eclipse.jdt.core.dom.ParenthesizedExpression;
+import org.eclipse.jdt.core.dom.PostfixExpression;
+import org.eclipse.jdt.core.dom.PrefixExpression;
+import org.eclipse.jdt.core.dom.PrimitiveType;
+import org.eclipse.jdt.core.dom.QualifiedName;
+import org.eclipse.jdt.core.dom.ReturnStatement;
+import org.eclipse.jdt.core.dom.SimpleName;
+import org.eclipse.jdt.core.dom.SimpleType;
+import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
+import org.eclipse.jdt.core.dom.StringLiteral;
+import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
+import org.eclipse.jdt.core.dom.SuperFieldAccess;
+import org.eclipse.jdt.core.dom.SuperMethodInvocation;
+import org.eclipse.jdt.core.dom.SwitchCase;
+import org.eclipse.jdt.core.dom.SwitchStatement;
+import org.eclipse.jdt.core.dom.SynchronizedStatement;
+import org.eclipse.jdt.core.dom.ThisExpression;
+import org.eclipse.jdt.core.dom.ThrowStatement;
+import org.eclipse.jdt.core.dom.TryStatement;
+import org.eclipse.jdt.core.dom.TypeDeclaration;
+import org.eclipse.jdt.core.dom.TypeDeclarationStatement;
+import org.eclipse.jdt.core.dom.TypeLiteral;
+import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
+import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
+import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
+import org.eclipse.jdt.core.dom.WhileStatement;
+
+/**
+ * Compute a valid location where to put a breakpoint from an JDOM CompilationUnit.
+ * The result is the first valid location with a line number greater or equals than the given position.
+ */
+public class ValidBreakpointLocationLocator extends ASTVisitor {
+
+ private CompilationUnit fCompilationUnit;
+ private int fPosition;
+ private int fPositionLine;
+
+ private int fLocation;
+ private boolean fLocationFound;
+ private String fTypeName;
+
+ /**
+ * @param compilationUnit the JDOM CompilationUnit of the source code.
+ * @param position the offset in the source code where to put the breakpoint.
+ */
+ public ValidBreakpointLocationLocator(CompilationUnit compilationUnit, int position) {
+ fCompilationUnit= compilationUnit;
+ fPosition= position;
+ fPositionLine= fCompilationUnit.lineNumber(fPosition);
+ fLocationFound= false;
+ }
+
+ /**
+ * Return the line number of the computed valid location, or -1 if no valid location has been found.
+ */
+ public int getValidLocation() {
+ if (fLocationFound) {
+ return fLocation;
+ } else {
+ return -1;
+ }
+ }
+
+ /**
+ * Return of the type where the valid location is, or null if no valid location has been found.
+ */
+ public String getFullyQualifiedTypeName() {
+ return fTypeName;
+ }
+
+ /**
+ * Compute the name of the type which contains this node.
+ * Result will be the name of the type or the inner type which contains this node, but not of the local or anonymous type.
+ */
+ private void computeTypeName(ASTNode node) {
+ while (!(node instanceof CompilationUnit)) {
+ if (node instanceof TypeDeclaration) {
+ String identifier= ((TypeDeclaration)node).getName().getIdentifier();
+ if (fTypeName == null) {
+ fTypeName= identifier;
+ } else {
+ fTypeName= identifier + "$" + fTypeName; //$NON-NLS-1$
+ }
+ } else {
+ fTypeName= null;
+ }
+ node= node.getParent();
+ }
+ PackageDeclaration packageDecl= ((CompilationUnit)node).getPackage();
+ String packageIdentifier= ""; //$NON-NLS-1$
+ if (packageDecl != null) {
+ Name packageName= packageDecl.getName();
+ while (packageName.isQualifiedName()) {
+ QualifiedName qualifiedName= (QualifiedName) packageName;
+ packageIdentifier= qualifiedName.getName().getIdentifier() + "." + packageIdentifier; //$NON-NLS-1$
+ packageName= qualifiedName.getQualifier();
+ }
+ packageIdentifier= ((SimpleName)packageName).getIdentifier() + "." + packageIdentifier; //$NON-NLS-1$
+ }
+ fTypeName= packageIdentifier + fTypeName;
+ }
+
+ /**
+ * @param node the node.
+ * @param isCode true indicated that the first line of the given node always contains some executable code, even if split in multiple lines.
+ * @return
+ */
+ private boolean visit(ASTNode node, boolean isCode) {
+ int startPosition= node.getStartPosition();
+ int endPosition = startPosition + node.getLength();
+ // if we already found a correct location, or if the position is not in this part of the code,
+ // no need to check the element inside.
+ if (fLocationFound || endPosition < fPosition) {
+ return false;
+ }
+ int startLine = fCompilationUnit.lineNumber(startPosition);
+ // if it is a structure, or there is more than one line of code, go in
+ if (isCode && (fPositionLine == startLine || startLine == fCompilationUnit.lineNumber(endPosition))) {
+ fLocation= startLine;
+ fLocationFound= true;
+ computeTypeName(node);
+ return false;
+ }
+ return true;
+ }
+
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.AnonymousClassDeclaration)
+ */
+ public boolean visit(AnonymousClassDeclaration node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayAccess)
+ */
+ public boolean visit(ArrayAccess node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayCreation)
+ */
+ public boolean visit(ArrayCreation node) {
+ return visit(node, node.getInitializer() == null);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayInitializer)
+ */
+ public boolean visit(ArrayInitializer node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayType)
+ */
+ public boolean visit(ArrayType node) {
+ return false;
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.AssertStatement)
+ */
+ public boolean visit(AssertStatement node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Assignment)
+ */
+ public boolean visit(Assignment node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Block)
+ */
+ public boolean visit(Block node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BooleanLiteral)
+ */
+ public boolean visit(BooleanLiteral node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BreakStatement)
+ */
+ public boolean visit(BreakStatement node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CastExpression)
+ */
+ public boolean visit(CastExpression node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CatchClause)
+ */
+ public boolean visit(CatchClause node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CharacterLiteral)
+ */
+ public boolean visit(CharacterLiteral node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ClassInstanceCreation)
+ */
+ public boolean visit(ClassInstanceCreation node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CompilationUnit)
+ */
+ public boolean visit(CompilationUnit node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConditionalExpression)
+ */
+ public boolean visit(ConditionalExpression node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConstructorInvocation)
+ */
+ public boolean visit(ConstructorInvocation node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ContinueStatement)
+ */
+ public boolean visit(ContinueStatement node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.DoStatement)
+ */
+ public boolean visit(DoStatement node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.EmptyStatement)
+ */
+ public boolean visit(EmptyStatement node) {
+ return false;
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ExpressionStatement)
+ */
+ public boolean visit(ExpressionStatement node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.FieldAccess)
+ */
+ public boolean visit(FieldAccess node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.FieldDeclaration)
+ */
+ public boolean visit(FieldDeclaration node) {
+ if (visit(node, false)) {
+ // visit only the variable declaration fragments, no the variable names.
+ List fragments= node.fragments();
+ for (Iterator iter= fragments.iterator(); iter.hasNext();) {
+ ((VariableDeclarationFragment)iter.next()).accept(this);
+ }
+ }
+ return false;
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ForStatement)
+ */
+ public boolean visit(ForStatement node) {
+ // in case on a "for(;;)", the breakpoint can be set on the first token of the node.
+ return visit(node, node.initializers().isEmpty() && node.getExpression() == null && node.updaters().isEmpty());
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.IfStatement)
+ */
+ public boolean visit(IfStatement node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ImportDeclaration)
+ */
+ public boolean visit(ImportDeclaration node) {
+ return false;
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InfixExpression)
+ */
+ public boolean visit(InfixExpression node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Initializer)
+ */
+ public boolean visit(Initializer node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InstanceofExpression)
+ */
+ public boolean visit(InstanceofExpression node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Javadoc)
+ */
+ public boolean visit(Javadoc node) {
+ return false;
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.LabeledStatement)
+ */
+ public boolean visit(LabeledStatement node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodDeclaration)
+ */
+ public boolean visit(MethodDeclaration node) {
+ if (visit(node, false)) {
+ // visit only the body
+ node.getBody().accept(this);
+ }
+ return false;
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
+ */
+ public boolean visit(MethodInvocation node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NullLiteral)
+ */
+ public boolean visit(NullLiteral node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NumberLiteral)
+ */
+ public boolean visit(NumberLiteral node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PackageDeclaration)
+ */
+ public boolean visit(PackageDeclaration node) {
+ return false;
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ParenthesizedExpression)
+ */
+ public boolean visit(ParenthesizedExpression node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PostfixExpression)
+ */
+ public boolean visit(PostfixExpression node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrefixExpression)
+ */
+ public boolean visit(PrefixExpression node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrimitiveType)
+ */
+ public boolean visit(PrimitiveType node) {
+ return false;
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.QualifiedName)
+ */
+ public boolean visit(QualifiedName node) {
+ visit(node, true);
+ return false;
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ReturnStatement)
+ */
+ public boolean visit(ReturnStatement node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleName)
+ */
+ public boolean visit(SimpleName node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleType)
+ */
+ public boolean visit(SimpleType node) {
+ return false;
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SingleVariableDeclaration)
+ */
+ public boolean visit(SingleVariableDeclaration node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.StringLiteral)
+ */
+ public boolean visit(StringLiteral node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperConstructorInvocation)
+ */
+ public boolean visit(SuperConstructorInvocation node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperFieldAccess)
+ */
+ public boolean visit(SuperFieldAccess node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperMethodInvocation)
+ */
+ public boolean visit(SuperMethodInvocation node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SwitchCase)
+ */
+ public boolean visit(SwitchCase node) {
+ return false;
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SwitchStatement)
+ */
+ public boolean visit(SwitchStatement node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SynchronizedStatement)
+ */
+ public boolean visit(SynchronizedStatement node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThisExpression)
+ */
+ public boolean visit(ThisExpression node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThrowStatement)
+ */
+ public boolean visit(ThrowStatement node) {
+ return visit(node, true);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TryStatement)
+ */
+ public boolean visit(TryStatement node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeDeclaration)
+ */
+ public boolean visit(TypeDeclaration node) {
+ if (visit(node, false)) {
+ // visit only the elements of the type declaration
+ List bodyDeclaration= node.bodyDeclarations();
+ for (Iterator iter= bodyDeclaration.iterator(); iter.hasNext();) {
+ ((BodyDeclaration)iter.next()).accept(this);
+ }
+ }
+ return false;
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeDeclarationStatement)
+ */
+ public boolean visit(TypeDeclarationStatement node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeLiteral)
+ */
+ public boolean visit(TypeLiteral node) {
+ return false;
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationExpression)
+ */
+ public boolean visit(VariableDeclarationExpression node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationFragment)
+ */
+ public boolean visit(VariableDeclarationFragment node) {
+ return visit(node, node.getInitializer() != null);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationStatement)
+ */
+ public boolean visit(VariableDeclarationStatement node) {
+ return visit(node, false);
+ }
+
+ /**
+ * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.WhileStatement)
+ */
+ public boolean visit(WhileStatement node) {
+ return visit(node, false);
+ }
+
+}
diff --git a/org.eclipse.jdt.launching/launching/org/eclipse/jdt/launching/sourcelookup/DirectorySourceLocation.java b/org.eclipse.jdt.launching/launching/org/eclipse/jdt/launching/sourcelookup/DirectorySourceLocation.java
index f915f36..9778851 100644
--- a/org.eclipse.jdt.launching/launching/org/eclipse/jdt/launching/sourcelookup/DirectorySourceLocation.java
+++ b/org.eclipse.jdt.launching/launching/org/eclipse/jdt/launching/sourcelookup/DirectorySourceLocation.java
@@ -18,7 +18,10 @@
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
+
import org.apache.xerces.dom.DocumentImpl;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IStatus;
@@ -85,6 +88,10 @@
String typeName = pathStr;
do {
IPath filePath = root.append(new Path(typeName + ".java")); //$NON-NLS-1$
+ IFile workspaceFile= ResourcesPlugin.getWorkspace().getRoot().getFileForLocation(filePath);
+ if (workspaceFile != null) {
+ return workspaceFile;
+ }
File file = filePath.toFile();
if (file.exists()) {
return new LocalFileStorage(file);
