diff --git a/org.eclipse.core.externaltools/src/org/eclipse/core/externaltools/internal/model/ExternalToolBuilder.java b/org.eclipse.core.externaltools/src/org/eclipse/core/externaltools/internal/model/ExternalToolBuilder.java
index 16ac512..ee9b495 100644
--- a/org.eclipse.core.externaltools/src/org/eclipse/core/externaltools/internal/model/ExternalToolBuilder.java
+++ b/org.eclipse.core.externaltools/src/org/eclipse/core/externaltools/internal/model/ExternalToolBuilder.java
@@ -43,7 +43,7 @@
  * build process.
  */
 public final class ExternalToolBuilder extends IncrementalProjectBuilder {
-	private final class IgnoreTeamPrivateChanges implements IResourceDeltaVisitor {
+	private static final class IgnoreTeamPrivateChanges implements IResourceDeltaVisitor {
 		private boolean[] fTrueChange;
 		private IgnoreTeamPrivateChanges(boolean[] trueChange) {
 			super();
diff --git a/org.eclipse.core.variables/src/org/eclipse/core/internal/variables/StringSubstitutionEngine.java b/org.eclipse.core.variables/src/org/eclipse/core/internal/variables/StringSubstitutionEngine.java
index 77fb387..cd41388 100644
--- a/org.eclipse.core.variables/src/org/eclipse/core/internal/variables/StringSubstitutionEngine.java
+++ b/org.eclipse.core.variables/src/org/eclipse/core/internal/variables/StringSubstitutionEngine.java
@@ -56,7 +56,7 @@
 	 */
 	private Deque<VariableReference> fStack;
 
-	class VariableReference {
+	static class VariableReference {
 
 		// the text inside the variable reference
 		private StringBuilder fText;
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/BreakpointManager.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/BreakpointManager.java
index ae1f02c..8725666 100644
--- a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/BreakpointManager.java
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/BreakpointManager.java
@@ -194,7 +194,7 @@
 	 *
 	 * @since 3.5
 	 */
-	class DefaultImportParticipant implements IBreakpointImportParticipant {
+	static class DefaultImportParticipant implements IBreakpointImportParticipant {
 
 		@Override
 		public boolean matches(Map<String, Object> attributes, IBreakpoint breakpoint) throws CoreException {
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/LaunchManager.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/LaunchManager.java
index fb9c0c7..d4689d0 100644
--- a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/LaunchManager.java
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/LaunchManager.java
@@ -442,7 +442,7 @@
 	 * Collects files whose extension matches the launch configuration file
 	 * extension.
 	 */
-	class ResourceProxyVisitor implements IResourceProxyVisitor {
+	static class ResourceProxyVisitor implements IResourceProxyVisitor {
 
 		private List<IResource> fList;
 
@@ -467,7 +467,7 @@
 	 *
 	 * @since 3.3
 	 */
-	class PreferredDelegate {
+	static class PreferredDelegate {
 		private ILaunchDelegate fDelegate = null;
 		private String fTypeid = null;
 		private Set<String> fModes = null;
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/NullStreamsProxy.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/NullStreamsProxy.java
index 494a9c2..a7ce39e 100644
--- a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/NullStreamsProxy.java
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/NullStreamsProxy.java
@@ -64,7 +64,7 @@
 	public void write(byte[] data, int offset, int length) throws IOException {
 	}
 
-	private class NullStreamMonitor implements IBinaryStreamMonitor {
+	private static class NullStreamMonitor implements IBinaryStreamMonitor {
 		private InputStream fStream;
 
 		public NullStreamMonitor(InputStream stream) {
diff --git a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/PreferredDelegateModifyListener.java b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/PreferredDelegateModifyListener.java
index fcba905..3133924 100644
--- a/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/PreferredDelegateModifyListener.java
+++ b/org.eclipse.debug.core/core/org/eclipse/debug/internal/core/PreferredDelegateModifyListener.java
@@ -27,7 +27,7 @@
  * @since 3.6 TODO can we roll this into general preference listening?
  */
 public class PreferredDelegateModifyListener extends PreferenceModifyListener {
-	class Visitor implements IPreferenceNodeVisitor {
+	static class Visitor implements IPreferenceNodeVisitor {
 
 		@Override
 		public boolean visit(IEclipsePreferences node) throws BackingStoreException {
diff --git a/org.eclipse.debug.examples.ui/src/org/eclipse/debug/examples/ui/pda/adapters/PDAVirtualFindAction.java b/org.eclipse.debug.examples.ui/src/org/eclipse/debug/examples/ui/pda/adapters/PDAVirtualFindAction.java
index 3e002de..37d115b 100644
--- a/org.eclipse.debug.examples.ui/src/org/eclipse/debug/examples/ui/pda/adapters/PDAVirtualFindAction.java
+++ b/org.eclipse.debug.examples.ui/src/org/eclipse/debug/examples/ui/pda/adapters/PDAVirtualFindAction.java
@@ -67,7 +67,7 @@
 
 	private final TreeModelViewer fClientViewer;
 
-	protected class VirtualViewerListener implements IViewerUpdateListener, ILabelUpdateListener {
+	protected static class VirtualViewerListener implements IViewerUpdateListener, ILabelUpdateListener {
 
 		private boolean fViewerUpdatesComplete = false;
 		private boolean fLabelUpdatesComplete = false;
diff --git a/org.eclipse.debug.examples.ui/src/org/eclipse/debug/examples/ui/pda/editor/PDAScanner.java b/org.eclipse.debug.examples.ui/src/org/eclipse/debug/examples/ui/pda/editor/PDAScanner.java
index aa586af..4de0f7c 100644
--- a/org.eclipse.debug.examples.ui/src/org/eclipse/debug/examples/ui/pda/editor/PDAScanner.java
+++ b/org.eclipse.debug.examples.ui/src/org/eclipse/debug/examples/ui/pda/editor/PDAScanner.java
@@ -39,7 +39,7 @@
 	/**
 	 * Detects potential keywords
 	 */
-	class PDAWordDetector implements IWordDetector {
+	static class PDAWordDetector implements IWordDetector {
 
 		@Override
 		public boolean isWordStart(char c) {
diff --git a/org.eclipse.debug.tests/src/org/eclipse/debug/tests/expressions/ExpressionManagerTests.java b/org.eclipse.debug.tests/src/org/eclipse/debug/tests/expressions/ExpressionManagerTests.java
index 6163253..64eb0fe 100644
--- a/org.eclipse.debug.tests/src/org/eclipse/debug/tests/expressions/ExpressionManagerTests.java
+++ b/org.eclipse.debug.tests/src/org/eclipse/debug/tests/expressions/ExpressionManagerTests.java
@@ -37,7 +37,7 @@
  */
 public class ExpressionManagerTests extends AbstractDebugTest {
 
-	class SinlgeListener implements IExpressionListener {
+	static class SinlgeListener implements IExpressionListener {
 
 		List<IExpression> added = new ArrayList<>();
 		List<IExpression> removed = new ArrayList<>();
@@ -66,7 +66,7 @@
 
 	}
 
-	class MultiListener implements IExpressionsListener {
+	static class MultiListener implements IExpressionsListener {
 
 		List<IExpression> added = new ArrayList<>();
 		List<IExpression> removed = new ArrayList<>();
@@ -95,7 +95,7 @@
 
 	}
 
-	class InsertMoveListener extends MultiListener implements IExpressionsListener2 {
+	static class InsertMoveListener extends MultiListener implements IExpressionsListener2 {
 
 		List<IExpression> moved = new ArrayList<>();
 		List<IExpression> inserted = new ArrayList<>();
diff --git a/org.eclipse.debug.tests/src/org/eclipse/debug/tests/launching/LaunchConfigurationTests.java b/org.eclipse.debug.tests/src/org/eclipse/debug/tests/launching/LaunchConfigurationTests.java
index 4c5b200..26e101c 100644
--- a/org.eclipse.debug.tests/src/org/eclipse/debug/tests/launching/LaunchConfigurationTests.java
+++ b/org.eclipse.debug.tests/src/org/eclipse/debug/tests/launching/LaunchConfigurationTests.java
@@ -101,7 +101,7 @@
 	 * Class to hold resource description infos
 	 * @since 3.9.0
 	 */
-	class ResourceItem {
+	static class ResourceItem {
 		public ResourceItem(String path, Integer type) {
 			this.path = path;
 			this.type = type;
@@ -110,7 +110,7 @@
 		Integer type;
 	}
 
-	class Listener implements ILaunchConfigurationListener {
+	static class Listener implements ILaunchConfigurationListener {
 
 		private final List<ILaunchConfiguration> addedList = new ArrayList<>();
 		private final List<ILaunchConfiguration> removedList = new ArrayList<>();
diff --git a/org.eclipse.debug.tests/src/org/eclipse/debug/tests/viewer/model/ColumnPresentationTests.java b/org.eclipse.debug.tests/src/org/eclipse/debug/tests/viewer/model/ColumnPresentationTests.java
index 7654bf6..1ac5939 100644
--- a/org.eclipse.debug.tests/src/org/eclipse/debug/tests/viewer/model/ColumnPresentationTests.java
+++ b/org.eclipse.debug.tests/src/org/eclipse/debug/tests/viewer/model/ColumnPresentationTests.java
@@ -213,7 +213,7 @@
 		}
 	}
 
-	class MyModel extends TestModel implements IColumnPresentationFactory {
+	static class MyModel extends TestModel implements IColumnPresentationFactory {
 		MyColumnPresentation colPresenation;
 
 		MyModel(MyColumnPresentation cp1) {
diff --git a/org.eclipse.debug.tests/src/org/eclipse/debug/tests/viewer/model/ContentTests.java b/org.eclipse.debug.tests/src/org/eclipse/debug/tests/viewer/model/ContentTests.java
index 0c844d4..0bd96f0 100644
--- a/org.eclipse.debug.tests/src/org/eclipse/debug/tests/viewer/model/ContentTests.java
+++ b/org.eclipse.debug.tests/src/org/eclipse/debug/tests/viewer/model/ContentTests.java
@@ -95,7 +95,7 @@
 	 * Modified test model that optionally captures (i.e. doesn't compete)
 	 * udpates after filling in their data.
 	 */
-	class TestModelWithCapturedUpdates extends TestModel {
+	static class TestModelWithCapturedUpdates extends TestModel {
 
 		boolean fCaptureLabelUpdates = false;
 		boolean fCaptureChildrenUpdates = false;
diff --git a/org.eclipse.debug.tests/src/org/eclipse/debug/tests/viewer/model/FilterTests.java b/org.eclipse.debug.tests/src/org/eclipse/debug/tests/viewer/model/FilterTests.java
index 1f003ab..d434780 100644
--- a/org.eclipse.debug.tests/src/org/eclipse/debug/tests/viewer/model/FilterTests.java
+++ b/org.eclipse.debug.tests/src/org/eclipse/debug/tests/viewer/model/FilterTests.java
@@ -49,7 +49,7 @@
 		return fViewer;
 	}
 
-	class TestViewerFilter extends ViewerFilter {
+	static class TestViewerFilter extends ViewerFilter {
 
 		Pattern fPattern;
 		TestViewerFilter(String pattern) {
@@ -68,7 +68,7 @@
 		}
 	}
 
-	class TestTMVFilter extends TreeModelViewerFilter {
+	static class TestTMVFilter extends TreeModelViewerFilter {
 		Pattern fPattern;
 		Object fParentElement;
 		TestTMVFilter(String pattern, Object parentElement) {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/MultipleInputDialog.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/MultipleInputDialog.java
index 5e30926..e3fd258 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/MultipleInputDialog.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/MultipleInputDialog.java
@@ -365,7 +365,7 @@
 		getButton(IDialogConstants.OK_ID).setEnabled(true);
 	}
 
-	protected class FieldSummary {
+	protected static class FieldSummary {
 		int type;
 		String name;
 		String initialValue;
@@ -379,7 +379,7 @@
 		}
 	}
 
-	protected class Validator {
+	protected static class Validator {
 		boolean validate() {
 			return true;
 		}
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/actions/ConfigureColumnsAction.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/actions/ConfigureColumnsAction.java
index c2c58f5..5157a00 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/actions/ConfigureColumnsAction.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/actions/ConfigureColumnsAction.java
@@ -43,7 +43,7 @@
 
 	private TreeModelViewer fViewer;
 
-	class ColumnContentProvider implements IStructuredContentProvider {
+	static class ColumnContentProvider implements IStructuredContentProvider {
 
 		@Override
 		public Object[] getElements(Object inputElement) {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/groups/CommonTabLite.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/groups/CommonTabLite.java
index d6ce28a..fdcfb1d 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/groups/CommonTabLite.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/groups/CommonTabLite.java
@@ -509,7 +509,7 @@
 	 * Provides the labels for the favorites table
 	 *
 	 */
-	class FavoritesLabelProvider implements ITableLabelProvider {
+	static class FavoritesLabelProvider implements ITableLabelProvider {
 
 		private Map<Object, Image> fImages = new HashMap<>();
 
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationManager.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationManager.java
index ec0934c..b2f01fd 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationManager.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationManager.java
@@ -102,7 +102,7 @@
 	 * A comparator for the ordering of launch shortcut extensions
 	 * @since 3.3
 	 */
-	class ShortcutComparator implements Comparator<LaunchShortcutExtension> {
+	static class ShortcutComparator implements Comparator<LaunchShortcutExtension> {
 		/**
 		 * @see Comparator#compare(Object, Object)
 		 */
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationTabGroupWrapper.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationTabGroupWrapper.java
index f45c628..f2f9e11 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationTabGroupWrapper.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchConfigurationTabGroupWrapper.java
@@ -45,7 +45,7 @@
 	 *
 	 * @since 3.5
 	 */
-	class TabCollector implements Iterator<ILaunchConfigurationTab> {
+	static class TabCollector implements Iterator<ILaunchConfigurationTab> {
 
 		private HashSet<String> idSet = null;
 		private ArrayList<ILaunchConfigurationTab> tabList = null;
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchShortcutExtension.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchShortcutExtension.java
index 7a48f5c..140647c 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchShortcutExtension.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/LaunchShortcutExtension.java
@@ -67,7 +67,7 @@
 	/**
 	 * Command handler for launch shortcut key binding.
 	 */
-	private class LaunchCommandHandler extends AbstractHandler {
+	private static class LaunchCommandHandler extends AbstractHandler {
 		// the shortcut to invoke
 		private LaunchShortcutExtension fShortcut;
 		private String fMode;
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/SelectLaunchModesDialog.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/SelectLaunchModesDialog.java
index 37b0b4a..ed6bab9 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/SelectLaunchModesDialog.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/launchConfigurations/SelectLaunchModesDialog.java
@@ -43,7 +43,7 @@
 	/**
 	 * Builds labels for list control
 	 */
-	class OptionsLabelProvider implements ILabelProvider {
+	static class OptionsLabelProvider implements ILabelProvider {
 		@Override
 		public Image getImage(Object element) {return null;}
 		@Override
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/memory/provisional/AbstractAsyncTableRendering.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/memory/provisional/AbstractAsyncTableRendering.java
index e7da67f..f91ff53 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/memory/provisional/AbstractAsyncTableRendering.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/memory/provisional/AbstractAsyncTableRendering.java
@@ -337,7 +337,7 @@
 		}
 	}
 
-	private class SerialByObjectRule implements ISchedulingRule {
+	private static class SerialByObjectRule implements ISchedulingRule {
 		private Object fObject = null;
 
 		public SerialByObjectRule(Object lock) {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/LaunchPerspectivePreferencePage.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/LaunchPerspectivePreferencePage.java
index c6055fa..2fc1bb8 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/LaunchPerspectivePreferencePage.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/LaunchPerspectivePreferencePage.java
@@ -127,7 +127,7 @@
 	/**
 	 * Provides content for the configuration tree viewer
 	 */
-	final class PerspectiveContentProvider implements ITreeContentProvider {
+	static final class PerspectiveContentProvider implements ITreeContentProvider {
 		@Override
 		public Object[] getChildren(Object parentElement) {
 			if(parentElement instanceof ILaunchConfigurationType) {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/LaunchersPreferencePage.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/LaunchersPreferencePage.java
index a769189..77f4c36 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/LaunchersPreferencePage.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/LaunchersPreferencePage.java
@@ -65,7 +65,7 @@
 	/**
 	 * Class to collect and persist attributes to sufficiently describe a duplicate launch delegate
 	 */
-	class DuplicateDelegate {
+	static class DuplicateDelegate {
 		private ILaunchConfigurationType fType = null;
 		private ILaunchDelegate[] fDelegates = null;
 		private Set<String> fModes = null;
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/StringVariablePreferencePage.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/StringVariablePreferencePage.java
index b03ab1e..b6a8ada 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/StringVariablePreferencePage.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/preferences/StringVariablePreferencePage.java
@@ -564,7 +564,7 @@
 
 	}
 
-	class VariableWrapper {
+	static class VariableWrapper {
 
 		protected IValueVariable fVariable;
 		protected String fNewName = null;
@@ -722,7 +722,7 @@
 		}
 	}
 
-	class VariableFilter extends ViewerFilter {
+	static class VariableFilter extends ViewerFilter {
 
 		@Override
 		public boolean select(Viewer viewer, Object parentElement, Object element) {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/AsynchronousModel.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/AsynchronousModel.java
index fdb5cc0..e09b9bf 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/AsynchronousModel.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/AsynchronousModel.java
@@ -66,7 +66,7 @@
 	private AsynchronousViewer fViewer; // viewer this model works for
 	private boolean fDisposed = false; // whether disposed
 
-	class EmptyContentAdapter extends AsynchronousContentAdapter {
+	static class EmptyContentAdapter extends AsynchronousContentAdapter {
 
 		@Override
 		protected Object[] getChildren(Object parent, IPresentationContext context) throws CoreException {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/AsynchronousSchedulingRuleFactory.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/AsynchronousSchedulingRuleFactory.java
index a9f1a0c..4f05e0b 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/AsynchronousSchedulingRuleFactory.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/AsynchronousSchedulingRuleFactory.java
@@ -27,7 +27,7 @@
 	/**
 	 * Rule allows only one job to run at a time
 	 */
-	class SerialRule implements ISchedulingRule {
+	static class SerialRule implements ISchedulingRule {
 
 		public SerialRule() {
 		}
@@ -43,7 +43,7 @@
 		}
 	}
 
-	class SerialPerObjectRule implements ISchedulingRule {
+	static class SerialPerObjectRule implements ISchedulingRule {
 
 		private Object fObject = null;
 
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/AsynchronousViewer.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/AsynchronousViewer.java
index aba77c7..b287456 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/AsynchronousViewer.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/AsynchronousViewer.java
@@ -643,7 +643,7 @@
 	/**
 	 * A content provider that does nothing.
 	 */
-	private class NullContentProvider implements IStructuredContentProvider {
+	private static class NullContentProvider implements IStructuredContentProvider {
 		@Override
 		public void dispose() {
 		}
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/model/VirtualCopyToClipboardActionDelegate.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/model/VirtualCopyToClipboardActionDelegate.java
index cab30d7..1c46d88 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/model/VirtualCopyToClipboardActionDelegate.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/model/VirtualCopyToClipboardActionDelegate.java
@@ -171,7 +171,7 @@
 		return label.trim();
 	}
 
-	private class ItemsToCopyVirtualItemValidator implements IVirtualItemValidator {
+	private static class ItemsToCopyVirtualItemValidator implements IVirtualItemValidator {
 
 		Set<VirtualItem> fItemsToCopy = Collections.EMPTY_SET;
 		Set<VirtualItem> fItemsToValidate = Collections.EMPTY_SET;
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/model/VirtualFindAction.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/model/VirtualFindAction.java
index f427d44..af81638 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/model/VirtualFindAction.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/viewers/model/VirtualFindAction.java
@@ -61,7 +61,7 @@
 
 	private TreeModelViewer fClientViewer;
 
-	private class VirtualViewerListener implements IViewerUpdateListener, ILabelUpdateListener {
+	private static class VirtualViewerListener implements IViewerUpdateListener, ILabelUpdateListener {
 
 		private boolean fViewerUpdatesComplete = false;
 		private boolean fLabelUpdatesComplete = false;
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/console/ProcessConsole.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/console/ProcessConsole.java
index 472a894..061e475 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/console/ProcessConsole.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/console/ProcessConsole.java
@@ -989,7 +989,7 @@
 		}
 	}
 
-	private class ConsoleLogFileHyperlink implements IHyperlink {
+	private static class ConsoleLogFileHyperlink implements IHyperlink {
 		String fFilePath;
 		ConsoleLogFileHyperlink(String filePath) {
 			fFilePath = filePath;
@@ -1024,7 +1024,7 @@
 		}
 	}
 
-	class StorageEditorInput extends PlatformObject implements IStorageEditorInput {
+	static class StorageEditorInput extends PlatformObject implements IStorageEditorInput {
 		private File fFile;
 		private IStorage fStorage;
 
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/AddMemoryRenderingDialog.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/AddMemoryRenderingDialog.java
index 427955b..f7d159b 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/AddMemoryRenderingDialog.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/AddMemoryRenderingDialog.java
@@ -112,7 +112,7 @@
 		job.schedule();
 	};
 
-	class MemoryRenderingLabelProvider implements ILabelProvider {
+	static class MemoryRenderingLabelProvider implements ILabelProvider {
 
 		@Override
 		public Image getImage(Object element) {
@@ -147,7 +147,7 @@
 
 	}
 
-	class MemoryRenderingContentProvider implements IStructuredContentProvider {
+	static class MemoryRenderingContentProvider implements IStructuredContentProvider {
 
 		@Override
 		public Object[] getElements(Object inputElement) {
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/MemoryView.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/MemoryView.java
index 9f4b8a6..f0c7f74 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/MemoryView.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/MemoryView.java
@@ -124,7 +124,7 @@
 
 	private String fActivePaneId;
 
-	class MemoryViewSelectionProvider implements ISelectionProvider, ISelectionChangedListener {
+	static class MemoryViewSelectionProvider implements ISelectionProvider, ISelectionChangedListener {
 		ArrayList<ISelectionChangedListener> fListeners = new ArrayList<>();
 
 		IStructuredSelection fSelections = new StructuredSelection();
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/MemoryViewSynchronizationService.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/MemoryViewSynchronizationService.java
index 9a5002d..9abc831 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/MemoryViewSynchronizationService.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/MemoryViewSynchronizationService.java
@@ -58,7 +58,7 @@
 	 * Wrapper for ISynchronizedMemoryBlockView Holds a list of property filters
 	 * for the view.
 	 */
-	class PropertyListener {
+	static class PropertyListener {
 		IPropertyChangeListener fListener;
 		String[] fFilters;
 
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/renderings/CreateRendering.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/renderings/CreateRendering.java
index 5c2d85b..a2f01ae 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/renderings/CreateRendering.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/memory/renderings/CreateRendering.java
@@ -78,7 +78,7 @@
 		fContainer = container;
 	}
 
-	class MemoryRenderingLabelProvider implements ILabelProvider
+	static class MemoryRenderingLabelProvider implements ILabelProvider
 	{
 
 		@Override
@@ -116,7 +116,7 @@
 
 	}
 
-	class MemoryRenderingContentProvider implements IStructuredContentProvider
+	static class MemoryRenderingContentProvider implements IStructuredContentProvider
 	{
 
 		@Override
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/variables/VariablesView.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/variables/VariablesView.java
index 8e59e6a..4dc79e2 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/variables/VariablesView.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/variables/VariablesView.java
@@ -340,7 +340,7 @@
 	/**
 	 * Visits deltas to determine if details should be displayed
 	 */
-	class Visitor implements IModelDeltaVisitor {
+	static class Visitor implements IModelDeltaVisitor {
 		/**
 		 * Whether to trigger details display.
 		 *
diff --git a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/variables/details/DetailPaneManager.java b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/variables/details/DetailPaneManager.java
index 9eea458..10cb57b 100644
--- a/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/variables/details/DetailPaneManager.java
+++ b/org.eclipse.debug.ui/ui/org/eclipse/debug/internal/ui/views/variables/details/DetailPaneManager.java
@@ -61,7 +61,7 @@
 	 * to the extension point.  Only loads information from the plug-in xml and only
 	 * instantiates the specified factory if required (lazy loading).
 	 */
-	private class DetailPaneFactoryExtension implements IDetailPaneFactory{
+	private static class DetailPaneFactoryExtension implements IDetailPaneFactory{
 
 		private IConfigurationElement fConfigElement;
 		private IDetailPaneFactory fFactory;
diff --git a/org.eclipse.ui.console/src/org/eclipse/ui/internal/console/ConsolePatternMatcher.java b/org.eclipse.ui.console/src/org/eclipse/ui/internal/console/ConsolePatternMatcher.java
index d6ca49b..c82ec6b 100644
--- a/org.eclipse.ui.console/src/org/eclipse/ui/internal/console/ConsolePatternMatcher.java
+++ b/org.eclipse.ui.console/src/org/eclipse/ui/internal/console/ConsolePatternMatcher.java
@@ -179,7 +179,7 @@
 
 	}
 
-	private class CompiledPatternMatchListener {
+	private static class CompiledPatternMatchListener {
 		Pattern pattern;
 
 		Pattern qualifier;
diff --git a/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/launchConfigurations/ExternalToolsBuildTab.java b/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/launchConfigurations/ExternalToolsBuildTab.java
index e9dfa46..efd5145 100644
--- a/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/launchConfigurations/ExternalToolsBuildTab.java
+++ b/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/launchConfigurations/ExternalToolsBuildTab.java
@@ -79,7 +79,7 @@
 	// projects to build (empty if none)
 	private List<IProject> fProjects = new ArrayList<>();
 
-	class ProjectsContentProvider implements IStructuredContentProvider {
+	static class ProjectsContentProvider implements IStructuredContentProvider {
 
 		@Override
 		public Object[] getElements(Object inputElement) {
diff --git a/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/launchConfigurations/ExternalToolsMainTab.java b/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/launchConfigurations/ExternalToolsMainTab.java
index 8b8a8b4..0eab24c 100644
--- a/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/launchConfigurations/ExternalToolsMainTab.java
+++ b/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/launchConfigurations/ExternalToolsMainTab.java
@@ -626,7 +626,7 @@
 		control.getAccessible().addAccessibleListener(new ControlAccessibleListener(stripped.toString()));
 	}
 
-	private class ControlAccessibleListener extends AccessibleAdapter {
+	private static class ControlAccessibleListener extends AccessibleAdapter {
 		private String controlName;
 		ControlAccessibleListener(String name) {
 			controlName = name;
diff --git a/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/model/ExternalToolsPlugin.java b/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/model/ExternalToolsPlugin.java
index 1e75be8..3d66b86 100644
--- a/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/model/ExternalToolsPlugin.java
+++ b/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/model/ExternalToolsPlugin.java
@@ -63,7 +63,7 @@
 	 * A window listener that warns the user about any running programs when the
 	 * workbench closes. Programs are killed when the VM exits.
 	 */
-	private class ProgramLaunchWindowListener implements IWindowListener {
+	private static class ProgramLaunchWindowListener implements IWindowListener {
 		@Override
 		public void windowActivated(IWorkbenchWindow window) {
 		}
diff --git a/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/ui/BuilderPropertyPage.java b/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/ui/BuilderPropertyPage.java
index 2bee78f..66f4b54 100644
--- a/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/ui/BuilderPropertyPage.java
+++ b/org.eclipse.ui.externaltools/External Tools Base/org/eclipse/ui/externaltools/internal/ui/BuilderPropertyPage.java
@@ -116,7 +116,7 @@
 	 * Error configs are objects representing entries pointing to
 	 * invalid launch configurations
 	 */
-	public class ErrorConfig {
+	public static class ErrorConfig {
 		private ICommand command;
 		public ErrorConfig(ICommand command) {
 			this.command= command;
