org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/BreakpointMarkerUpdater.java - jdt/eclipse.jdt.debug - Git at Google

 /*******************************************************************************
  * Copyright (c) 2006, 2015 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.internal.debug.ui;

 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IMarker;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.debug.core.DebugPlugin;
 import org.eclipse.debug.core.IBreakpointManager;
 import org.eclipse.debug.core.model.IBreakpoint;
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jdt.core.JavaCore;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jdt.debug.core.IJavaLineBreakpoint;
 import org.eclipse.jdt.debug.core.IJavaPatternBreakpoint;
 import org.eclipse.jdt.debug.core.IJavaStratumLineBreakpoint;
 import org.eclipse.jdt.debug.core.IJavaWatchpoint;
 import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
 import org.eclipse.jdt.internal.debug.core.JavaDebugUtils;
 import org.eclipse.jdt.internal.debug.core.breakpoints.JavaLineBreakpoint;
 import org.eclipse.jdt.internal.debug.core.breakpoints.ValidBreakpointLocationLocator;
 import org.eclipse.jdt.ui.SharedASTProvider;
 import org.eclipse.jface.text.BadLocationException;
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.IRegion;
 import org.eclipse.jface.text.Position;
 import org.eclipse.ui.texteditor.IMarkerUpdater;
 import org.eclipse.ui.texteditor.MarkerUtilities;

 /**
  * This class provides a mechanism to correct the placement of a
  * breakpoint marker when the related document is edited.
  *
  * This updater is used to cover the line number discrepancy cases that <code>BasicMarkerUpdater</code> does not:
  * <ul>
  * <li>If you insert a blank line at the start of the line of code, the breakpoint
  * is moved from the blank line to the next viable line down,
  * following the same breakpoint placement rules as creating a breakpoint</li>
  *
  * <li>If you select the contents of an entire line and delete them
  * (leaving the line blank), the breakpoint is moved to the next viable line down,
  * following the same breakpoint placement rules as creating a breakpoint</li>
  *
  * <li>If the breakpoint is on the last viable line of a class file and the line is removed via either of
  * the aforementioned deletion cases, the breakpoint is removed</li>
  *
  * <li>If a line breakpoint would be moved to a valid method location with an invalid line number it is removed,
  * see  {@link https://bugs.eclipse.org/bugs/show_bug.cgi?id=188676} for details</li>
  *
  * <li>If a line breakpoint will be moved to a line that already has a line breakpoint on it, the one
  * being moved is removed, see {@link https://bugs.eclipse.org/bugs/show_bug.cgi?id=129066} for details</li>
  *
  * <li>In the general deletion case if a valid breakpoint location can not be determined, it is removed</li>
  * </ul>
  *
  * @since 3.3
  */
 public class BreakpointMarkerUpdater implements IMarkerUpdater {

 	public BreakpointMarkerUpdater() {}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ui.texteditor.IMarkerUpdater#getAttribute()
 	 */
 	@Override
 	public String[] getAttribute() {
 		return new String[] {IMarker.LINE_NUMBER};
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ui.texteditor.IMarkerUpdater#getMarkerType()
 	 */
 	@Override
 	public String getMarkerType() {
 		return "org.eclipse.debug.core.breakpointMarker"; //$NON-NLS-1$
 	}

 	/* (non-Javadoc)
 	 * @see org.eclipse.ui.texteditor.IMarkerUpdater#updateMarker(org.eclipse.core.resources.IMarker, org.eclipse.jface.text.IDocument, org.eclipse.jface.text.Position)
 	 */
 	@Override
 	public boolean updateMarker(IMarker marker, IDocument document, Position position) {
 		if(position.isDeleted()) {
 			return false;
 		}
 		IBreakpointManager manager = DebugPlugin.getDefault().getBreakpointManager();
 		IBreakpoint breakpoint = manager.getBreakpoint(marker);
 		if(breakpoint == null) {
 			return false;
 		}
 		if (breakpoint instanceof IJavaStratumLineBreakpoint || breakpoint instanceof IJavaPatternBreakpoint) {
 			return true;
 		}
 		ICompilationUnit cunit = JavaCore.createCompilationUnitFrom((IFile) marker.getResource());
 		if(cunit == null) {
 			return false;
 		}
 		CompilationUnit unit = SharedASTProvider.getAST(cunit, SharedASTProvider.WAIT_YES, null);
 		if(unit == null) {
 			//remove it - in case it would be left in a bad location
 			return false;
 		}
 		try {
 			ValidBreakpointLocationLocator loc = new ValidBreakpointLocationLocator(unit, document.getLineOfOffset(position.getOffset())+1, true, true);
 			unit.accept(loc);
 			if(loc.getLocationType() == ValidBreakpointLocationLocator.LOCATION_NOT_FOUND) {
 				return false;
 			}
 			// Remove the watch point if it is not a valid watch point now
 			if (loc.getLocationType() != ValidBreakpointLocationLocator.LOCATION_FIELD && breakpoint instanceof IJavaWatchpoint) {
 				return false;
 			}
 			int line = loc.getLineLocation();
 			//if the line number is already good, perform no marker updating
 			if(MarkerUtilities.getLineNumber(marker) == line) {
 				//if there exists a breakpoint on the line remove this one
 				if(isLineBreakpoint(marker)) {
 					ensureRanges(document, marker, line);
 					return lineBreakpointExists(marker.getResource(), ((IJavaLineBreakpoint)breakpoint).getTypeName(), line, marker) == null;
 				}
 				return true;
 			}
 			//if the line info is a valid location with an invalid line number,
 			//a line breakpoint must be removed
 			if(isLineBreakpoint(marker) & line == -1) {
 				return false;
 			}
 			MarkerUtilities.setLineNumber(marker, line);
 			if(isLineBreakpoint(marker)) {
 				ensureRanges(document, marker, line);
 			}
 			return true;
 		}
 		catch (BadLocationException e) {JDIDebugUIPlugin.log(e);}
 		catch (CoreException e) {JDIDebugUIPlugin.log(e);}
 		return false;
 	}

 	/**
 	 * Updates the charstart and charend ranges if necessary for the given line.
 	 * Returns immediately if the line is not valid (< 0 or greater than the total line number count)
 	 * @param document
 	 * @param marker
 	 * @param line
 	 * @throws BadLocationException
 	 */
 	private void ensureRanges(IDocument document, IMarker marker, int line) throws BadLocationException {
 		if(line < 0 || line > document.getNumberOfLines()) {
 			return;
 		}
 		IRegion region = document.getLineInformation(line - 1);
 		int charstart = region.getOffset();
 		int charend = charstart + region.getLength();
 		MarkerUtilities.setCharStart(marker, charstart);
 		MarkerUtilities.setCharEnd(marker, charend);
 	}

 	/**
 	 * Returns if the specified marker is for an <code>IJavaLineBreakpoint</code>
 	 * @param marker
 	 * @return true if the marker is for an <code>IJavalineBreakpoint</code>, false otherwise
 	 *
 	 * @since 3.4
 	 */
 	private boolean isLineBreakpoint(IMarker marker) {
 		return MarkerUtilities.isMarkerType(marker, "org.eclipse.jdt.debug.javaLineBreakpointMarker"); //$NON-NLS-1$
 	}

 	/**
 	 * Searches for an existing line breakpoint on the specified line in the current type that does not match the id of the specified marker
 	 * @param resource the resource to care about
 	 * @param typeName the name of the type the breakpoint is in
 	 * @param lineNumber the number of the line the breakpoint is on
 	 * @param currentmarker the current marker we are comparing to see if it will be moved onto an existing one
 	 * @return an existing line breakpoint on the current line of the given resource and type if there is one
 	 * @throws CoreException
 	 *
 	 * @since 3.4
 	 */
 	private IJavaLineBreakpoint lineBreakpointExists(IResource resource, String typeName, int lineNumber, IMarker currentmarker) throws CoreException {
 		String modelId = JDIDebugPlugin.getUniqueIdentifier();
 		String markerType= JavaLineBreakpoint.getMarkerType();
 		IBreakpointManager manager= DebugPlugin.getDefault().getBreakpointManager();
 		IBreakpoint[] breakpoints= manager.getBreakpoints(modelId);
 		for (int i = 0; i < breakpoints.length; i++) {
 			if (!(breakpoints[i] instanceof IJavaLineBreakpoint)) {
 				continue;
 			}
 			IJavaLineBreakpoint breakpoint = (IJavaLineBreakpoint) breakpoints[i];
 			IMarker marker = breakpoint.getMarker();
 			if (marker != null && marker.exists() && marker.getType().equals(markerType) && currentmarker.getId() != marker.getId()) {
 				String breakpointTypeName = breakpoint.getTypeName();
 				if ((JavaDebugUtils.typeNamesEqual(breakpointTypeName, typeName) || (breakpointTypeName != null && breakpointTypeName.startsWith(typeName + '$')))
 						&& breakpoint.getLineNumber() == lineNumber && resource.equals(marker.getResource())) {
 						return breakpoint;
 				}
 			}
 		}
 		return null;
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2006, 2015 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.internal.debug.ui;

	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IMarker;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.debug.core.DebugPlugin;
	import org.eclipse.debug.core.IBreakpointManager;
	import org.eclipse.debug.core.model.IBreakpoint;
	import org.eclipse.jdt.core.ICompilationUnit;
	import org.eclipse.jdt.core.JavaCore;
	import org.eclipse.jdt.core.dom.CompilationUnit;
	import org.eclipse.jdt.debug.core.IJavaLineBreakpoint;
	import org.eclipse.jdt.debug.core.IJavaPatternBreakpoint;
	import org.eclipse.jdt.debug.core.IJavaStratumLineBreakpoint;
	import org.eclipse.jdt.debug.core.IJavaWatchpoint;
	import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
	import org.eclipse.jdt.internal.debug.core.JavaDebugUtils;
	import org.eclipse.jdt.internal.debug.core.breakpoints.JavaLineBreakpoint;
	import org.eclipse.jdt.internal.debug.core.breakpoints.ValidBreakpointLocationLocator;
	import org.eclipse.jdt.ui.SharedASTProvider;
	import org.eclipse.jface.text.BadLocationException;
	import org.eclipse.jface.text.IDocument;
	import org.eclipse.jface.text.IRegion;
	import org.eclipse.jface.text.Position;
	import org.eclipse.ui.texteditor.IMarkerUpdater;
	import org.eclipse.ui.texteditor.MarkerUtilities;

	/**
	* This class provides a mechanism to correct the placement of a
	* breakpoint marker when the related document is edited.
	*
	* This updater is used to cover the line number discrepancy cases that <code>BasicMarkerUpdater</code> does not:
	* <ul>
	* <li>If you insert a blank line at the start of the line of code, the breakpoint
	* is moved from the blank line to the next viable line down,
	* following the same breakpoint placement rules as creating a breakpoint</li>
	*
	* <li>If you select the contents of an entire line and delete them
	* (leaving the line blank), the breakpoint is moved to the next viable line down,
	* following the same breakpoint placement rules as creating a breakpoint</li>
	*
	* <li>If the breakpoint is on the last viable line of a class file and the line is removed via either of
	* the aforementioned deletion cases, the breakpoint is removed</li>
	*
	* <li>If a line breakpoint would be moved to a valid method location with an invalid line number it is removed,
	* see {@link https://bugs.eclipse.org/bugs/show_bug.cgi?id=188676} for details</li>
	*
	* <li>If a line breakpoint will be moved to a line that already has a line breakpoint on it, the one
	* being moved is removed, see {@link https://bugs.eclipse.org/bugs/show_bug.cgi?id=129066} for details</li>
	*
	* <li>In the general deletion case if a valid breakpoint location can not be determined, it is removed</li>
	* </ul>
	*
	* @since 3.3
	*/
	public class BreakpointMarkerUpdater implements IMarkerUpdater {

	public BreakpointMarkerUpdater() {}

	/* (non-Javadoc)
	* @see org.eclipse.ui.texteditor.IMarkerUpdater#getAttribute()
	*/
	@Override
	public String[] getAttribute() {
	return new String[] {IMarker.LINE_NUMBER};
	}

	/* (non-Javadoc)
	* @see org.eclipse.ui.texteditor.IMarkerUpdater#getMarkerType()
	*/
	@Override
	public String getMarkerType() {
	return "org.eclipse.debug.core.breakpointMarker"; //$NON-NLS-1$
	}

	/* (non-Javadoc)
	* @see org.eclipse.ui.texteditor.IMarkerUpdater#updateMarker(org.eclipse.core.resources.IMarker, org.eclipse.jface.text.IDocument, org.eclipse.jface.text.Position)
	*/
	@Override
	public boolean updateMarker(IMarker marker, IDocument document, Position position) {
	if(position.isDeleted()) {
	return false;
	}
	IBreakpointManager manager = DebugPlugin.getDefault().getBreakpointManager();
	IBreakpoint breakpoint = manager.getBreakpoint(marker);
	if(breakpoint == null) {
	return false;
	}
	if (breakpoint instanceof IJavaStratumLineBreakpoint \|\| breakpoint instanceof IJavaPatternBreakpoint) {
	return true;
	}
	ICompilationUnit cunit = JavaCore.createCompilationUnitFrom((IFile) marker.getResource());
	if(cunit == null) {
	return false;
	}
	CompilationUnit unit = SharedASTProvider.getAST(cunit, SharedASTProvider.WAIT_YES, null);
	if(unit == null) {
	//remove it - in case it would be left in a bad location
	return false;
	}
	try {
	ValidBreakpointLocationLocator loc = new ValidBreakpointLocationLocator(unit, document.getLineOfOffset(position.getOffset())+1, true, true);
	unit.accept(loc);
	if(loc.getLocationType() == ValidBreakpointLocationLocator.LOCATION_NOT_FOUND) {
	return false;
	}
	// Remove the watch point if it is not a valid watch point now
	if (loc.getLocationType() != ValidBreakpointLocationLocator.LOCATION_FIELD && breakpoint instanceof IJavaWatchpoint) {
	return false;
	}
	int line = loc.getLineLocation();
	//if the line number is already good, perform no marker updating
	if(MarkerUtilities.getLineNumber(marker) == line) {
	//if there exists a breakpoint on the line remove this one
	if(isLineBreakpoint(marker)) {
	ensureRanges(document, marker, line);
	return lineBreakpointExists(marker.getResource(), ((IJavaLineBreakpoint)breakpoint).getTypeName(), line, marker) == null;
	}
	return true;
	}
	//if the line info is a valid location with an invalid line number,
	//a line breakpoint must be removed
	if(isLineBreakpoint(marker) & line == -1) {
	return false;
	}
	MarkerUtilities.setLineNumber(marker, line);
	if(isLineBreakpoint(marker)) {
	ensureRanges(document, marker, line);
	}
	return true;
	}
	catch (BadLocationException e) {JDIDebugUIPlugin.log(e);}
	catch (CoreException e) {JDIDebugUIPlugin.log(e);}
	return false;
	}

	/**
	* Updates the charstart and charend ranges if necessary for the given line.
	* Returns immediately if the line is not valid (< 0 or greater than the total line number count)
	* @param document
	* @param marker
	* @param line
	* @throws BadLocationException
	*/
	private void ensureRanges(IDocument document, IMarker marker, int line) throws BadLocationException {
	if(line < 0 \|\| line > document.getNumberOfLines()) {
	return;
	}
	IRegion region = document.getLineInformation(line - 1);
	int charstart = region.getOffset();
	int charend = charstart + region.getLength();
	MarkerUtilities.setCharStart(marker, charstart);
	MarkerUtilities.setCharEnd(marker, charend);
	}

	/**
	* Returns if the specified marker is for an <code>IJavaLineBreakpoint</code>
	* @param marker
	* @return true if the marker is for an <code>IJavalineBreakpoint</code>, false otherwise
	*
	* @since 3.4
	*/
	private boolean isLineBreakpoint(IMarker marker) {
	return MarkerUtilities.isMarkerType(marker, "org.eclipse.jdt.debug.javaLineBreakpointMarker"); //$NON-NLS-1$
	}

	/**
	* Searches for an existing line breakpoint on the specified line in the current type that does not match the id of the specified marker
	* @param resource the resource to care about
	* @param typeName the name of the type the breakpoint is in
	* @param lineNumber the number of the line the breakpoint is on
	* @param currentmarker the current marker we are comparing to see if it will be moved onto an existing one
	* @return an existing line breakpoint on the current line of the given resource and type if there is one
	* @throws CoreException
	*
	* @since 3.4
	*/
	private IJavaLineBreakpoint lineBreakpointExists(IResource resource, String typeName, int lineNumber, IMarker currentmarker) throws CoreException {
	String modelId = JDIDebugPlugin.getUniqueIdentifier();
	String markerType= JavaLineBreakpoint.getMarkerType();
	IBreakpointManager manager= DebugPlugin.getDefault().getBreakpointManager();
	IBreakpoint[] breakpoints= manager.getBreakpoints(modelId);
	for (int i = 0; i < breakpoints.length; i++) {
	if (!(breakpoints[i] instanceof IJavaLineBreakpoint)) {
	continue;
	}
	IJavaLineBreakpoint breakpoint = (IJavaLineBreakpoint) breakpoints[i];
	IMarker marker = breakpoint.getMarker();
	if (marker != null && marker.exists() && marker.getType().equals(markerType) && currentmarker.getId() != marker.getId()) {
	String breakpointTypeName = breakpoint.getTypeName();
	if ((JavaDebugUtils.typeNamesEqual(breakpointTypeName, typeName) \|\| (breakpointTypeName != null && breakpointTypeName.startsWith(typeName + '$')))
	&& breakpoint.getLineNumber() == lineNumber && resource.equals(marker.getResource())) {
	return breakpoint;
	}
	}
	}
	return null;
	}

	}