From 5fe49cd7be7373b758959bae85045f19214a9e86 Mon Sep 17 00:00:00 2001
From: sougandhs <sougandh.s@ibm.com>
Date: Mon, 6 Jan 2025 13:57:19 +0530
Subject: [PATCH] This commit provides support for Primitive types and
 Primitive arrays in Detail Formatter for variables view.

Fixes : https://github.com/eclipse-jdt/eclipse.jdt.debug/issues/268
---
 .../jdt/debug/tests/AbstractDebugTest.java    |   1 +
 .../tests/variables/DetailFormatterTests.java | 136 ++++++++++++++
 .../a/b/c/primitivesTest.java                 |  28 +++
 org.eclipse.jdt.debug.ui/plugin.xml           |  19 +-
 .../internal/debug/ui/DebugUIMessages.java    |   2 +
 .../debug/ui/DebugUIMessages.properties       |   2 +
 .../debug/ui/DetailFormatterDialog.java       |  66 ++++++-
 .../debug/ui/JavaDetailFormattersManager.java | 166 +++++++++++++++++-
 .../debug/ui/JavaVarActionFilter.java         |   5 +
 .../jdt/debug/eval/IAstEvaluationEngine.java  |  37 ++++
 .../eval/ast/engine/ASTEvaluationEngine.java  |  20 +++
 .../eval/ast/engine/IRuntimeContext.java      |   5 +
 .../engine/JavaPrimitiveRuntimeContext.java   |  92 ++++++++++
 13 files changed, 551 insertions(+), 28 deletions(-)
 create mode 100644 org.eclipse.jdt.debug.tests/testsource-j2se-1.5/a/b/c/primitivesTest.java
 create mode 100644 org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/JavaPrimitiveRuntimeContext.java

diff --git a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/AbstractDebugTest.java b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/AbstractDebugTest.java
index 9e60b1c4f3..f32f2d2cd7 100644
--- a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/AbstractDebugTest.java
+++ b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/AbstractDebugTest.java
@@ -404,6 +404,7 @@ void assert15Project() {
 				cfgs.add(createLaunchConfiguration(jp, "a.b.c.bug329294WithGenerics"));
 				cfgs.add(createLaunchConfiguration(jp, "a.b.c.bug403028"));
 				cfgs.add(createLaunchConfiguration(jp, "a.b.c.bug484686"));
+				cfgs.add(createLaunchConfiguration(jp, "a.b.c.primitivesTest"));
 				cfgs.add(createLaunchConfiguration(jp, "a.b.c.GenericMethodEntryTest"));
 				cfgs.add(createLaunchConfiguration(jp, "org.eclipse.debug.tests.targets.HcrClass", true));
 				cfgs.add(createLaunchConfiguration(jp, "a.b.c.Bug570988"));
diff --git a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/variables/DetailFormatterTests.java b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/variables/DetailFormatterTests.java
index 0c685e5c07..1a09782dd1 100644
--- a/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/variables/DetailFormatterTests.java
+++ b/org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/tests/variables/DetailFormatterTests.java
@@ -340,4 +340,140 @@ public void testHoverWithNoTypeArguments() throws Exception {
 			removeAllBreakpoints();
 		}
 	}
+
+	public void testFormatterForPrimitivesInt() throws Exception {
+		IJavaThread thread = null;
+		DetailFormatter formatter = null;
+		JavaDetailFormattersManager jdfm = JavaDetailFormattersManager.getDefault();
+		try {
+			String typename = "a.b.c.primitivesTest";
+			createLineBreakpoint(26, typename);
+			thread = launchToBreakpoint(typename);
+			assertNotNull("The program did not suspend", thread);
+			String snippet = "this + 12";
+			formatter = new DetailFormatter("int", snippet, true);
+			jdfm.setAssociatedDetailFormatter(formatter);
+			IJavaVariable var = thread.findVariable("x");
+			assertNotNull("the variable 'x' must exist in the frame", var);
+			jdfm.computeValueDetail((IJavaValue) var.getValue(), thread, fListener);
+			waitForListenerValue();
+			assertNotNull("The IValue of the detailComputed callback cannot be null", fListener.value);
+			assertEquals("24", fListener.result.toString());
+
+			snippet = "new String(this)"; // for char arrays formatter = new DetailFormatter("char[]", snippet, true);
+			jdfm.setAssociatedDetailFormatter(formatter);
+			var = thread.findVariable("aCh");
+			assertNotNull("the variable 'aCh' must exist in the frame", var);
+			jdfm.computeValueDetail((IJavaValue) var.getValue(), thread, fListener);
+			waitForListenerValue();
+			assertNotNull("The IValue of the detailComputed callback cannot be null", fListener.value);
+			assertEquals("ab", fListener.result.toString());
+
+		} finally {
+			jdfm.removeAssociatedDetailFormatter(formatter);
+			terminateAndRemove(thread);
+			removeAllBreakpoints();
+		}
+	}
+
+	public void testFormatterForPrimitivesfloat() throws Exception {
+		IJavaThread thread = null;
+		DetailFormatter formatter = null;
+		JavaDetailFormattersManager jdfm = JavaDetailFormattersManager.getDefault();
+		try {
+			String typename = "a.b.c.primitivesTest";
+			createLineBreakpoint(26, typename);
+			thread = launchToBreakpoint(typename);
+			assertNotNull("The program did not suspend", thread);
+			String snippet = "this + 10";
+			formatter = new DetailFormatter("float", snippet, true);
+			jdfm.setAssociatedDetailFormatter(formatter);
+			IJavaVariable var = thread.findVariable("f");
+			assertNotNull("the variable 'f' must exist in the frame", var);
+			jdfm.computeValueDetail((IJavaValue) var.getValue(), thread, fListener);
+			waitForListenerValue();
+			assertNotNull("The IValue of the detailComputed callback cannot be null", fListener.value);
+			assertEquals("20", fListener.result.toString());
+		} finally {
+			jdfm.removeAssociatedDetailFormatter(formatter);
+			terminateAndRemove(thread);
+			removeAllBreakpoints();
+		}
+	}
+
+	public void testFormatterForPrimitivesIntArrays() throws Exception {
+		IJavaThread thread = null;
+		DetailFormatter formatter = null;
+		JavaDetailFormattersManager jdfm = JavaDetailFormattersManager.getDefault();
+		try {
+			String typename = "a.b.c.primitivesTest";
+			createLineBreakpoint(26, typename);
+			thread = launchToBreakpoint(typename);
+			assertNotNull("The program did not suspend", thread);
+			String snippet = "this[1]";
+			formatter = new DetailFormatter("int[]", snippet, true);
+			jdfm.setAssociatedDetailFormatter(formatter);
+			IJavaVariable var = thread.findVariable("arInt");
+			assertNotNull("the variable 'arInt' must exist in the frame", var);
+			jdfm.computeValueDetail((IJavaValue) var.getValue(), thread, fListener);
+			waitForListenerValue();
+			assertNotNull("The IValue of the detailComputed callback cannot be null", fListener.value);
+			assertEquals("2", fListener.result.toString());
+		} finally {
+			jdfm.removeAssociatedDetailFormatter(formatter);
+			terminateAndRemove(thread);
+			removeAllBreakpoints();
+		}
+	}
+
+	public void testFormatterForPrimitivesIntArraysMulti() throws Exception {
+		IJavaThread thread = null;
+		DetailFormatter formatter = null;
+		JavaDetailFormattersManager jdfm = JavaDetailFormattersManager.getDefault();
+		try {
+			String typename = "a.b.c.primitivesTest";
+			createLineBreakpoint(26, typename);
+			thread = launchToBreakpoint(typename);
+			assertNotNull("The program did not suspend", thread);
+			String snippet = "this[0][0]";
+			formatter = new DetailFormatter("int[][]", snippet, true);
+			jdfm.setAssociatedDetailFormatter(formatter);
+			IJavaVariable var = thread.findVariable("mul");
+			assertNotNull("the variable 'mul' must exist in the frame", var);
+			jdfm.computeValueDetail((IJavaValue) var.getValue(), thread, fListener);
+			waitForListenerValue();
+			assertNotNull("The IValue of the detailComputed callback cannot be null", fListener.value);
+			assertEquals("[1]", fListener.result.toString());
+		} finally {
+			jdfm.removeAssociatedDetailFormatter(formatter);
+			terminateAndRemove(thread);
+			removeAllBreakpoints();
+		}
+	}
+
+	public void testFormatterForPrimitivesCharArray() throws Exception {
+		IJavaThread thread = null;
+		DetailFormatter formatter = null;
+		JavaDetailFormattersManager jdfm = JavaDetailFormattersManager.getDefault();
+		try {
+			String typename = "a.b.c.primitivesTest";
+			createLineBreakpoint(26, typename);
+			thread = launchToBreakpoint(typename);
+			assertNotNull("The program did not suspend", thread);
+			String snippet = "new String(this)";
+			formatter = new DetailFormatter("char[]", snippet, true);
+			jdfm.setAssociatedDetailFormatter(formatter);
+			IJavaVariable var = thread.findVariable("aCh");
+			assertNotNull("the variable 'aCh' must exist in the frame", var);
+			jdfm.computeValueDetail((IJavaValue) var.getValue(), thread, fListener);
+			waitForListenerValue();
+			assertNotNull("The IValue of the detailComputed callback cannot be null", fListener.value);
+			assertEquals("ab", fListener.result.toString());
+		} finally {
+			jdfm.removeAssociatedDetailFormatter(formatter);
+			terminateAndRemove(thread);
+			removeAllBreakpoints();
+		}
+	}
+
 }
diff --git a/org.eclipse.jdt.debug.tests/testsource-j2se-1.5/a/b/c/primitivesTest.java b/org.eclipse.jdt.debug.tests/testsource-j2se-1.5/a/b/c/primitivesTest.java
new file mode 100644
index 0000000000..3e1a7a841d
--- /dev/null
+++ b/org.eclipse.jdt.debug.tests/testsource-j2se-1.5/a/b/c/primitivesTest.java
@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * Copyright (c) 2025 IBM Corporation and others.
+ *
+ * This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License 2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *     IBM Corporation - initial API and implementation
+ *******************************************************************************/
+package a.b.c;
+
+public class primitivesTest {
+	public static void main(String[] args) {
+		Double xd = Double.valueOf(1);
+		int x = 12;
+		float f = 10;
+		int[] arInt = { 1, 2, 3 };
+		char[] aCh = { 'a', 'b' };
+		boolean b = false;
+		double[] d = { 1, 3, 4 };
+		int[][] mul = { { 1, 3, 4 }, { 1, 3, 4 } };
+		int p1 = 120;
+	}
+}
diff --git a/org.eclipse.jdt.debug.ui/plugin.xml b/org.eclipse.jdt.debug.ui/plugin.xml
index 718a2c9a99..5adba5ecc5 100644
--- a/org.eclipse.jdt.debug.ui/plugin.xml
+++ b/org.eclipse.jdt.debug.ui/plugin.xml
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <?eclipse version="3.0"?>
 <!--
-     Copyright (c) 2005, 2022 IBM Corporation and others.
+     Copyright (c) 2005, 2025 IBM Corporation and others.
 
      This program and the accompanying materials
      are made available under the terms of the Eclipse Public License 2.0
@@ -745,22 +745,12 @@
             id="org.eclipse.jdt.debug.ui.FilteredJavaVariableActions">
          <visibility>
             <and>
-               <objectState
-                     name="PrimitiveVariableActionFilter"
-                     value="isValuePrimitive">
-               </objectState>
                <not>
                   <objectState
                         name="DetailFormatterFilter"
                         value="isDefined">
                   </objectState>
                </not>
-               <not>
-                  <objectState
-                        name="PrimitiveVariableActionFilter"
-                        value="isArray">
-                  </objectState>
-               </not>
                <not>
                   <objectState
                         name="JavaVariableFilter"
@@ -804,15 +794,8 @@
                      name="DetailFormatterFilter"
                      value="inSuperclass"/>
             </or>
-            <not>
-               <objectState
-                     name="PrimitiveVariableActionFilter"
-                     value="isArray">
-               </objectState>
-            </not>
           </and>
          </visibility>
-
       </objectContribution>
       <objectContribution
             id="org.eclipse.jdt.debug.ui.FilteredJavaVariableActions"
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.java
index 223d5fa756..a56fb76dda 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.java
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.java
@@ -308,6 +308,8 @@ public class DebugUIMessages extends NLS {
 	public static String DetailFormatterDialog_Associated_code_must_not_be_empty_3;
 	public static String DetailFormatterDialog_Detail_formatter__code_snippet__1;
 	public static String DetailFormatterDialog_17;
+	public static String DetailFormatterPrimitiveSelect;
+	public static String DetailFormatterPrimitiveSelectionLabel;
 
 	public static String No_type_with_the_given_name_found_in_the_workspace__1;
 	public static String JavaDetailFormattersManager_Detail_formatter_error___1;
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.properties b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.properties
index e93b81afbd..e88bd10e2d 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.properties
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DebugUIMessages.properties
@@ -254,6 +254,8 @@ DetailFormatterDialog_Add_Detail_Formatter_2=Add Detail Formatter
 DetailFormatterDialog_Associated_code_must_not_be_empty_3=Detail formatter code snippet must not be empty
 DetailFormatterDialog_Detail_formatter__code_snippet__1=Detail formatter &code snippet:
 DetailFormatterDialog_17=Detail formatter &code snippet ({0} for code assist):
+DetailFormatterPrimitiveSelect=Select Primitives
+DetailFormatterPrimitiveSelectionLabel=Choose a primitive
 
 No_type_with_the_given_name_found_in_the_workspace__1=No type with the given name found in the workspace.
 JavaDetailFormattersManager_Detail_formatter_error___1=Detail formatter error:
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DetailFormatterDialog.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DetailFormatterDialog.java
index 47d7830e81..1c693bf214 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DetailFormatterDialog.java
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/DetailFormatterDialog.java
@@ -51,6 +51,9 @@
 import org.eclipse.jface.text.IDocumentListener;
 import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
 import org.eclipse.jface.text.source.ISourceViewer;
+import org.eclipse.jface.viewers.ArrayContentProvider;
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.jface.window.Window;
 import org.eclipse.osgi.util.NLS;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.events.ModifyEvent;
@@ -67,6 +70,7 @@
 import org.eclipse.ui.IWorkbench;
 import org.eclipse.ui.IWorkbenchCommandConstants;
 import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.dialogs.ListDialog;
 import org.eclipse.ui.dialogs.SelectionDialog;
 import org.eclipse.ui.handlers.IHandlerActivation;
 import org.eclipse.ui.handlers.IHandlerService;
@@ -168,11 +172,10 @@ protected Control createDialogArea(Composite parent) {
 		Font font = parent.getFont();
 		Composite container = (Composite)super.createDialogArea(parent);
 
-		SWTFactory.createLabel(container, DebugUIMessages.DetailFormatterDialog_Qualified_type__name__2, 1);
+		SWTFactory.createLabel(container, DebugUIMessages.DetailFormatterDialog_Qualified_type__name__2, 2);
 
 		Composite innerContainer = SWTFactory.createComposite(container, font, 2, 1, GridData.FILL_HORIZONTAL);
-
-		fTypeNameText = SWTFactory.createSingleText(innerContainer, 1);
+		fTypeNameText = SWTFactory.createSingleText(innerContainer, 2);
 		fTypeNameText.setEditable(fEditTypeName);
 		fTypeNameText.setText(fDetailFormatter.getTypeName());
 		fTypeNameText.addModifyListener(new ModifyListener() {
@@ -182,9 +185,23 @@ public void modifyText(ModifyEvent e) {
 				checkValues();
 			}
 		});
+		Button primitiveSearchButton = SWTFactory.createPushButton(innerContainer, DebugUIMessages.DetailFormatterPrimitiveSelect, null);
+		primitiveSearchButton.setEnabled(fEditTypeName);
+
+		GridData gridLayout = new GridData(GridData.FILL_HORIZONTAL);
+		gridLayout.horizontalSpan = 1;
+		gridLayout.grabExcessHorizontalSpace = true;
+		primitiveSearchButton.setLayoutData(gridLayout);
+		primitiveSearchButton.addListener(SWT.Selection, new Listener() {
+			@Override
+			public void handleEvent(Event e) {
+				selectPrimitiveType();
+			}
+		});
 
 		Button typeSearchButton = SWTFactory.createPushButton(innerContainer, DebugUIMessages.DetailFormatterDialog_Select__type_4, null);
 		typeSearchButton.setEnabled(fEditTypeName);
+		typeSearchButton.setLayoutData(gridLayout);
 		typeSearchButton.addListener(SWT.Selection, new Listener() {
 			@Override
 			public void handleEvent(Event e) {
@@ -192,6 +209,7 @@ public void handleEvent(Event e) {
 			}
 		});
 
+
 		String labelText = null;
 		IBindingService bindingService = workbench.getAdapter(IBindingService.class);
 		String binding = bindingService.getBestActiveBindingFormattedFor(IWorkbenchCommandConstants.EDIT_CONTENT_ASSIST);
@@ -281,7 +299,7 @@ private void checkValues() {
 			status.setError(DebugUIMessages.DetailFormatterDialog_A_detail_formatter_is_already_defined_for_this_type_2);
 		} else if (fSnippetViewer.getDocument().get().trim().length() == 0) {
 			status.setError(DebugUIMessages.DetailFormatterDialog_Associated_code_must_not_be_empty_3);
-		} else if (fType == null && fTypeSearched) {
+		} else if (fType == null && fTypeSearched && !getPrimitiveTypes().contains(typeName)) {
 			status.setWarning(DebugUIMessages.No_type_with_the_given_name_found_in_the_workspace__1);
 		}
 		updateStatus(status);
@@ -307,14 +325,13 @@ private void selectType() {
 		SelectionDialog dialog= null;
 		try {
 			dialog= JavaUI.createTypeDialog(shell, PlatformUI.getWorkbench().getProgressService(),
-				SearchEngine.createWorkspaceScope(), IJavaElementSearchConstants.CONSIDER_ALL_TYPES, false, fTypeNameText.getText());
+					SearchEngine.createWorkspaceScope(), IJavaElementSearchConstants.CONSIDER_ALL_TYPES, false, fTypeNameText.getText());
 		} catch (JavaModelException jme) {
 			String title= DebugUIMessages.DetailFormatterDialog_Select_type_6;
 			String message= DebugUIMessages.DetailFormatterDialog_Could_not_open_type_selection_dialog_for_detail_formatters_7;
 			ExceptionHandler.handle(jme, title, message);
 			return;
 		}
-
 		dialog.setTitle(DebugUIMessages.DetailFormatterDialog_Select_type_8);
 		dialog.setMessage(DebugUIMessages.DetailFormatterDialog_Select_a_type_to_format_when_displaying_its_detail_9);
 		if (dialog.open() == IDialogConstants.CANCEL_ID) {
@@ -329,6 +346,43 @@ private void selectType() {
 		}
 	}
 
+	/**
+	 * Open the 'select type' dialog, and set the primitive into the formatter.
+	 */
+	private void selectPrimitiveType() {
+		Shell shell = getShell();
+		ListDialog listDialog = new ListDialog(shell);
+		listDialog.setTitle(DebugUIMessages.DetailFormatterDialog_Select_type_8);
+		listDialog.setMessage(DebugUIMessages.DetailFormatterPrimitiveSelectionLabel);
+		listDialog.setInput(getPrimitiveTypes().toArray());
+		listDialog.setContentProvider(ArrayContentProvider.getInstance());
+		listDialog.setLabelProvider(new LabelProvider() {
+			@Override
+			public String getText(Object element) {
+				return (String) element;
+			}
+		});
+		if (listDialog.open() == Window.CANCEL) {
+			return;
+		}
+		Object[] types = listDialog.getResult();
+		if (types != null && types.length > 0) {
+			String s = (String) types[0];
+			fTypeNameText.setText(s);
+			fTypeSearched = true;
+		}
+	}
+
+	/**
+	 * Returns a List of available primitives and arrays
+	 *
+	 * @return List primitives and arrays
+	 */
+	@SuppressWarnings("nls")
+	private List<String> getPrimitiveTypes() {
+		return List.of("int", "long", "short", "float", "double", "boolean", "char", "byte", "int[]", "long[]", "short[]", "float[]", "double[]", "boolean[]", "char[]", "byte[]");
+	}
+
 	/**
 	 * Use the Java search engine to find the type which corresponds
 	 * to the given name.
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaDetailFormattersManager.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaDetailFormattersManager.java
index 41d1001a03..82b63c87dc 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaDetailFormattersManager.java
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaDetailFormattersManager.java
@@ -57,6 +57,7 @@
 import org.eclipse.jdt.internal.debug.core.logicalstructures.JDIAllInstancesValue;
 import org.eclipse.jdt.internal.debug.core.model.JDINullValue;
 import org.eclipse.jdt.internal.debug.core.model.JDIReferenceListValue;
+import org.eclipse.jdt.internal.debug.core.model.JDIType;
 import org.eclipse.jface.util.IPropertyChangeListener;
 import org.eclipse.jface.util.PropertyChangeEvent;
 import org.eclipse.osgi.util.NLS;
@@ -142,7 +143,7 @@ public void run() {
 	}
 
 	private void resolveFormatter(final IJavaValue value, final IJavaThread thread, final IValueDetailListener listener) {
-		EvaluationListener evaluationListener= new EvaluationListener(value, thread, listener);
+		EvaluationListener evaluationListener = new EvaluationListener(value, thread, listener);
 		if (value instanceof IJavaObject) {
 			IJavaObject objectValue= (IJavaObject) value;
 			try {
@@ -167,6 +168,19 @@ private void resolveFormatter(final IJavaValue value, final IJavaThread thread,
 				return;
 			}
 		}
+		if (value instanceof IJavaPrimitiveValue primeValue) {
+			try {
+				IJavaDebugTarget debugTarget= (IJavaDebugTarget) thread.getDebugTarget();
+				Expression expression= getCompiledExpression(primeValue, debugTarget, thread);
+				if (expression != null) {
+					expression.getEngine().evaluateExpression(expression.getExpression(), primeValue, thread, evaluationListener, DebugEvent.EVALUATION_IMPLICIT, false);
+					return;
+				}
+			} catch (CoreException e) {
+				listener.detailComputed(value, e.toString());
+				return;
+			}
+		}
 		try {
 			evaluationListener.valueToString(value);
 		} catch (DebugException e) {
@@ -180,7 +194,7 @@ private void resolveFormatter(final IJavaValue value, final IJavaThread thread,
 		}
 	}
 
-	private IJavaProject getJavaProject(IJavaObject javaValue, IJavaThread thread) throws CoreException {
+	private IJavaProject getJavaProject(IJavaValue javaValue, IJavaThread thread) throws CoreException {
 
 		IType type = null;
 		if (javaValue instanceof IJavaArray) {
@@ -289,6 +303,8 @@ public DetailFormatter getAssociatedDetailFormatter(IJavaType type) {
 			}
 			if (type instanceof IJavaClassType) {
 				typeName = type.getName();
+			} else if (type instanceof JDIType) {
+				typeName = type.getName();
 			}
 			else {
 				return null;
@@ -298,6 +314,7 @@ public DetailFormatter getAssociatedDetailFormatter(IJavaType type) {
 		return fDetailFormattersMap.get(typeName);
 	}
 
+
 	public void setAssociatedDetailFormatter(DetailFormatter detailFormatter) {
 		fDetailFormattersMap.put(detailFormatter.getTypeName(), detailFormatter);
 		savePreference();
@@ -340,6 +357,23 @@ private String getDetailFormatter(IJavaClassType type) throws DebugException {
 		return null;
 	}
 
+	/**
+	 * Return the detail formatter (code snippet) associate with the given type
+	 *
+	 * @param type
+	 *            the JDIType type
+	 * @return the code snippet for the given JDIType
+	 * @throws DebugException
+	 *             if there is problem computing the snippet
+	 */
+	private String getDetailFormatter(JDIType type) throws DebugException {
+		String snippet = getDetailFormatterForPrimitives(type);
+		if (snippet != null) {
+			return snippet;
+		}
+		return null;
+	}
+
 	/**
 	 * Return the detail formatter (code snippet) associate with
 	 * the given type or one of its super types.
@@ -358,6 +392,34 @@ private String getDetailFormatterSuperClass(IJavaClassType type) throws DebugExc
 		return getDetailFormatterSuperClass(type.getSuperclass());
 	}
 
+	/**
+	 * Return the detail formatter (code snippet) associate with the given type or one of its super types.
+	 *
+	 * @param type
+	 *            the Array type
+	 * @return the snippet for the given class / super class
+	 * @throws DebugException
+	 *             if there is a problem computing the snippet
+	 */
+	private String getDetailFormatterFromArray(IJavaArrayType type) throws DebugException {
+		if (type == null) {
+			return null;
+		}
+		DetailFormatter detailFormatter = fDetailFormattersMap.get(type.getName());
+		if (detailFormatter != null && detailFormatter.isEnabled()) {
+			return detailFormatter.getSnippet();
+		}
+		return null;
+	}
+
+	private String getDetailFormatterForPrimitives(JDIType type) throws DebugException {
+		DetailFormatter detailFormatter = fDetailFormattersMap.get(type.getName());
+		if (detailFormatter != null && detailFormatter.isEnabled()) {
+			return detailFormatter.getSnippet();
+		}
+		return null;
+	}
+
 	/**
 	 * Return the expression which corresponds to the code formatter associated with the type of
 	 * the given object or <code>null</code> if none.
@@ -384,12 +446,13 @@ private Expression getCompiledExpression(IJavaObject javaObject, IJavaDebugTarge
 		if (type instanceof IJavaClassType) {
 			snippet = getDetailFormatter((IJavaClassType) type);
 		}
-		if (type instanceof IJavaArrayType) {
+		if (type instanceof IJavaArrayType jArray) {
 			if (JavaCore.compareJavaVersions(debugTarget.getVersion(), JavaCore.VERSION_9) < 0) {
 				snippet = getArraySnippet((IJavaArray) javaObject);
+			} else {
+				snippet = getDetailFormatterFromArray(jArray);
 			}
 		}
-
 		if (snippet != null) {
 			IJavaProject project = getJavaProject(javaObject, thread);
 			if (project != null) {
@@ -407,6 +470,101 @@ private Expression getCompiledExpression(IJavaObject javaObject, IJavaDebugTarge
 		return null;
 	}
 
+	/**
+	 * Return the expression which corresponds to the code formatter associated with the type of the given primitive or <code>null</code> if none.
+	 *
+	 * The code snippet is compiled in the context of the given object.
+	 *
+	 * @param IJavaPrimitiveValue
+	 *            the primitive object
+	 * @param debugTarget
+	 *            the target
+	 * @param thread
+	 *            the thread context
+	 * @return the compiled expression to be evaluated
+	 * @throws CoreException
+	 *             is a problem occurs compiling the expression
+	 */
+	private Expression getCompiledExpression(IJavaPrimitiveValue javaPM, IJavaDebugTarget debugTarget, IJavaThread thread) throws CoreException {
+		IJavaType type = javaPM.getJavaType();
+		if (type == null) {
+			return null;
+		}
+		String snippet = null;
+
+		if (type instanceof JDIType jdiType) {
+			snippet = getDetailFormatter(jdiType);
+			if (snippet == null) {
+				return null;
+			}
+			snippet = primitiveSnippets(snippet, jdiType.getName(), javaPM);
+		}
+		if (type instanceof IJavaArrayType) {
+			if (JavaCore.compareJavaVersions(debugTarget.getVersion(), JavaCore.VERSION_9) < 0) {
+				snippet = getArraySnippet((IJavaArray) javaPM);
+			}
+		}
+		if (snippet != null) {
+			IJavaProject project = getJavaProject(javaPM, thread);
+			if (project != null) {
+				IAstEvaluationEngine evaluationEngine = JDIDebugPlugin.getDefault().getEvaluationEngine(project, debugTarget);
+				ICompiledExpression res = evaluationEngine.getCompiledExpression(snippet, (IJavaStackFrame) thread.getTopStackFrame());
+				if (res != null) {
+					Expression exp = new Expression(res, evaluationEngine);
+					return exp;
+				}
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Return the modified expression which replaces this keyword used in formatter
+	 *
+	 * The code snippet is compiled in the context of the given object.
+	 *
+	 * @param snippet
+	 *            Original snippet
+	 * @param typeName
+	 *            type of the primitive
+	 * @param primitiveValue
+	 *            primitive object
+	 * @return modified expression to be evaluated
+	 */
+	@SuppressWarnings("nls")
+	private String primitiveSnippets(String snippet, String typeName, IJavaPrimitiveValue primitiveValue) {
+		String modified = null;
+		if (typeName.equals("float")) {
+			String thisValue = Float.valueOf(primitiveValue.getFloatValue()).toString();
+			modified = snippet.replace("this", thisValue);
+		} else if (typeName.equals("int")) {
+			String thisValue = Integer.valueOf(primitiveValue.getIntValue()).toString();
+			modified = snippet.replace("this", thisValue);
+		} else if (typeName.equals("byte")) {
+			String thisValue = Byte.valueOf(primitiveValue.getByteValue()).toString();
+			modified = snippet.replace("this", thisValue);
+		} else if (typeName.equals("long")) {
+			String thisValue = Long.valueOf(primitiveValue.getLongValue()).toString();
+			modified = snippet.replace("this", thisValue);
+		} else if (typeName.equals("short")) {
+			String thisValue = Short.valueOf(primitiveValue.getShortValue()).toString();
+			modified = snippet.replace("this", thisValue);
+		} else if (typeName.equals("double")) {
+			String thisValue = Double.valueOf(primitiveValue.getDoubleValue()).toString();
+			modified = snippet.replace("this", thisValue);
+		} else if (typeName.equals("boolean")) {
+			String thisValue = Boolean.valueOf(primitiveValue.getBooleanValue()).toString();
+			modified = snippet.replace("this", thisValue);
+		} else if (typeName.equals("char")) {
+			String thisValue = Character.valueOf(primitiveValue.getCharValue()).toString();
+			modified = snippet.replace("this", thisValue);
+		}  else {
+			modified = snippet;
+		}
+		return modified;
+
+	}
+
 	protected String getArraySnippet(IJavaArray value) throws DebugException {
 		String signature = value.getSignature();
 		int nesting = Signature.getArrayCount(signature);
diff --git a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaVarActionFilter.java b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaVarActionFilter.java
index 447fd29a01..77e4f2bc62 100644
--- a/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaVarActionFilter.java
+++ b/org.eclipse.jdt.debug.ui/ui/org/eclipse/jdt/internal/debug/ui/JavaVarActionFilter.java
@@ -23,6 +23,7 @@
 import org.eclipse.jdt.debug.core.IJavaDebugTarget;
 import org.eclipse.jdt.debug.core.IJavaFieldVariable;
 import org.eclipse.jdt.debug.core.IJavaObject;
+import org.eclipse.jdt.debug.core.IJavaPrimitiveValue;
 import org.eclipse.jdt.debug.core.IJavaType;
 import org.eclipse.jdt.debug.core.IJavaVariable;
 import org.eclipse.jdt.internal.debug.core.model.JDINullValue;
@@ -227,6 +228,10 @@ else if (name.equals("DetailFormatterFilter") && (varValue instanceof IJavaObjec
 					if(value.equals("inSuperclass")) { //$NON-NLS-1$
 						return JavaDetailFormattersManager.getDefault().hasSuperclassDetailFormatter(((IJavaObject)varValue).getJavaType());
 					}
+				} else if (name.equals("DetailFormatterFilter") && (varValue instanceof IJavaPrimitiveValue javaPrime)) { //$NON-NLS-1$
+					if (value.equals("isDefined")) { //$NON-NLS-1$
+						return JavaDetailFormattersManager.getDefault().hasAssociatedDetailFormatter(javaPrime.getJavaType());
+					}
 				}
 			} catch (DebugException e) {}
 		}
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/debug/eval/IAstEvaluationEngine.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/debug/eval/IAstEvaluationEngine.java
index 394f322f36..143e37b378 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/debug/eval/IAstEvaluationEngine.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/debug/eval/IAstEvaluationEngine.java
@@ -17,6 +17,7 @@
 
 import org.eclipse.debug.core.DebugException;
 import org.eclipse.jdt.debug.core.IJavaObject;
+import org.eclipse.jdt.debug.core.IJavaPrimitiveValue;
 import org.eclipse.jdt.debug.core.IJavaReferenceType;
 import org.eclipse.jdt.debug.core.IJavaStackFrame;
 import org.eclipse.jdt.debug.core.IJavaThread;
@@ -132,6 +133,42 @@ public void evaluateExpression(ICompiledExpression expression,
 			IEvaluationListener listener, int evaluationDetail,
 			boolean hitBreakpoints) throws DebugException;
 
+	/**
+	 * Asynchronously evaluates the given expression in the context of the specified type, reporting the result back to the given listener. The
+	 * expression is evaluated in the context of the Java project this evaluation engine was created on. If the expression is determined to have no
+	 * errors, the expression is evaluated in the thread associated with the given stack frame. When the evaluation completes, the thread will be
+	 * suspended at this original location. The thread runs the evaluation with the given evaluation detail (@see
+	 * IJavaThread#runEvaluation(IEvaluationRunnable, IProgressMonitor, int)). Compilation and runtime errors are reported in the evaluation result.
+	 *
+	 * @param expression
+	 *            the expression to evaluate
+	 * @param object
+	 *            primitive 'this' context for the evaluation
+	 * @param thread
+	 *            the thread in which to run the evaluation, which must be suspended
+	 * @param listener
+	 *            the listener that will receive notification when/if the evaluation completes
+	 * @param evaluationDetail
+	 *            bitmask of one of <code>DebugEvent.EVALUATION</code> or <code>DebugEvent.EVALUATION_IMPLICIT</code> and optionally
+	 *            <code>DISABLE_GC_ON_RESULT</code>
+	 * @param hitBreakpoints
+	 *            whether or not breakpoints should be honored in the evaluation thread during the evaluation. If <code>false</code>, breakpoints hit
+	 *            in the evaluation thread will be ignored.
+	 * @exception DebugException
+	 *                if this method fails. Reasons include:
+	 *                <ul>
+	 *                <li>Failure communicating with the VM. The DebugException's status code contains the underlying exception responsible for the
+	 *                failure.</li>
+	 *                <li>The associated thread is not currently suspended</li>
+	 *                <li>The stack frame is not contained in the debug target associated with this evaluation engine</li>
+	 *                <li>The associated thread is suspended in the middle of an evaluation that has not completed. It is not possible to perform
+	 *                nested evaluations</li>
+	 *                </ul>
+	 */
+	public void evaluateExpression(ICompiledExpression expression,
+			IJavaPrimitiveValue object, IJavaThread thread,
+			IEvaluationListener listener, int evaluationDetail,
+			boolean hitBreakpoints) throws DebugException;
 	/**
 	 * Synchronously generates a compiled expression from the given expression
 	 * in the context of the specified stack frame. The generated expression can
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/ASTEvaluationEngine.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/ASTEvaluationEngine.java
index 5a398535cf..21c2a7caab 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/ASTEvaluationEngine.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/ASTEvaluationEngine.java
@@ -53,6 +53,7 @@
 import org.eclipse.jdt.debug.core.IJavaArrayType;
 import org.eclipse.jdt.debug.core.IJavaDebugTarget;
 import org.eclipse.jdt.debug.core.IJavaObject;
+import org.eclipse.jdt.debug.core.IJavaPrimitiveValue;
 import org.eclipse.jdt.debug.core.IJavaReferenceType;
 import org.eclipse.jdt.debug.core.IJavaStackFrame;
 import org.eclipse.jdt.debug.core.IJavaThread;
@@ -216,6 +217,25 @@ public void evaluateExpression(ICompiledExpression expression, IJavaObject thisC
 		doEvaluation(expression, context, thread, listener, evaluationDetail, hitBreakpoints);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 *
+	 * @see org.eclipse.jdt.debug.eval.IAstEvaluationEngine#evaluateExpression(org .eclipse.jdt.debug.eval.ICompiledExpression,
+	 * org.eclipse.jdt.debug.core.IJavaPrimitiveValue, org.eclipse.jdt.debug.core.IJavaThread, org.eclipse.jdt.debug.eval.IEvaluationListener, int,
+	 * boolean)
+	 */
+	@Override
+	public void evaluateExpression(ICompiledExpression expression, IJavaPrimitiveValue thisContext, IJavaThread thread, IEvaluationListener listener, int evaluationDetail, boolean hitBreakpoints) throws DebugException {
+		traceCaller(expression.getSnippet(), thread);
+		IRuntimeContext context = null;
+		if (thisContext instanceof IJavaArray) {
+			context = new ArrayRuntimeContext((IJavaArray) thisContext, thread, getJavaProject());
+		} else {
+			context = new JavaPrimitiveRuntimeContext(thisContext, getJavaProject(), thread);
+		}
+		doEvaluation(expression, context, thread, listener, evaluationDetail, hitBreakpoints);
+	}
+
 	/**
 	 * Evaluates the given expression in the given thread and the given runtime context.
 	 */
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/IRuntimeContext.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/IRuntimeContext.java
index 9211dea19a..063d136201 100644
--- a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/IRuntimeContext.java
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/IRuntimeContext.java
@@ -19,6 +19,7 @@
 import org.eclipse.jdt.debug.core.IJavaClassObject;
 import org.eclipse.jdt.debug.core.IJavaDebugTarget;
 import org.eclipse.jdt.debug.core.IJavaObject;
+import org.eclipse.jdt.debug.core.IJavaPrimitiveValue;
 import org.eclipse.jdt.debug.core.IJavaReferenceType;
 import org.eclipse.jdt.debug.core.IJavaStackFrame;
 import org.eclipse.jdt.debug.core.IJavaThread;
@@ -55,6 +56,10 @@ public interface IRuntimeContext {
 	 */
 	IJavaObject getThis() throws CoreException;
 
+	default IJavaPrimitiveValue getThisPrimitive() {
+		return null;
+	}
+
 	/**
 	 * Returns the receiving type context in which to perform the evaluation. The type of 'this', or in the case of a static context, the class or
 	 * interface in which the evaluation is being performed.
diff --git a/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/JavaPrimitiveRuntimeContext.java b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/JavaPrimitiveRuntimeContext.java
new file mode 100644
index 0000000000..8cb2bed9ee
--- /dev/null
+++ b/org.eclipse.jdt.debug/eval/org/eclipse/jdt/internal/debug/eval/ast/engine/JavaPrimitiveRuntimeContext.java
@@ -0,0 +1,92 @@
+package org.eclipse.jdt.internal.debug.eval.ast.engine;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.debug.core.IJavaDebugTarget;
+import org.eclipse.jdt.debug.core.IJavaObject;
+import org.eclipse.jdt.debug.core.IJavaPrimitiveValue;
+import org.eclipse.jdt.debug.core.IJavaReferenceType;
+import org.eclipse.jdt.debug.core.IJavaThread;
+import org.eclipse.jdt.debug.core.IJavaVariable;
+
+public class JavaPrimitiveRuntimeContext extends AbstractRuntimeContext {
+	/**
+	 * <code>this</code> object or this context.
+	 */
+	private final IJavaPrimitiveValue fThisPrimitive;
+
+	/**
+	 * The thread for this context.
+	 */
+	private final IJavaThread fThread;
+
+	/**
+	 * ObjectValueRuntimeContext constructor.
+	 *
+	 * @param thisObject
+	 *            <code>this</code> object of this context.
+	 * @param javaProject
+	 *            the project for this context.
+	 * @param thread
+	 *            the thread for this context.
+	 */
+	public JavaPrimitiveRuntimeContext(IJavaPrimitiveValue thisObject, IJavaProject javaProject, IJavaThread thread) {
+		super(javaProject);
+		fThisPrimitive = thisObject;
+		fThread = thread;
+	}
+
+	/**
+	 * @see IRuntimeContext#getVM()
+	 */
+	@Override
+	public IJavaDebugTarget getVM() {
+		return (IJavaDebugTarget) fThisPrimitive.getDebugTarget();
+	}
+
+	/**
+	 * @see IRuntimeContext#getThis()
+	 */
+	@Override
+	public IJavaPrimitiveValue getThisPrimitive() {
+		return fThisPrimitive;
+	}
+
+	/**
+	 * @see IRuntimeContext#getReceivingType()
+	 */
+	@Override
+	public IJavaReferenceType getReceivingType() throws CoreException {
+		return (IJavaReferenceType) getThisPrimitive().getJavaType();
+	}
+
+	/**
+	 * @see IRuntimeContext#getLocals()
+	 */
+	@Override
+	public IJavaVariable[] getLocals() {
+		return new IJavaVariable[0];
+	}
+
+	/**
+	 * @see IRuntimeContext#getThread()
+	 */
+	@Override
+	public IJavaThread getThread() {
+		return fThread;
+	}
+
+	/**
+	 * @see IRuntimeContext#isConstructor()
+	 */
+	@Override
+	public boolean isConstructor() {
+		return false;
+	}
+
+	@Override
+	public IJavaObject getThis() throws CoreException {
+		return null;
+	}
+
+}