Don't expose a memory reference for non-pointer evaluation results (#1601)

Gate the memoryReference on pointer and array types in OpenDebugAD7

A non-pointer scalar shown in a data tip or the Variables view carried a
memoryReference, so VS Code rendered the "view binary data" icon and
navigated to an address equal to the value (hovering a uint32_t of 1
opened a memory view at 0x1).

The earlier approach gated AD7Property.GetMemoryContext in the engine, but
that method is shared with Visual Studio, where the Memory and Disassembly
windows resolve a typed address expression through it. Restricting it
there breaks entering a scalar or address expression into those windows.

Move the restriction to the DAP layer: in
AD7Utils.GetMemoryReferenceFromIDebugProperty, emit a memoryReference only
when the property type is a pointer or an array. GetMemoryContext is left
unchanged, so the Visual Studio memory and disassembly navigation keep
working, while VS Code no longer offers a memory view for scalars. VS Code
has no free-form address entry, so gating the reference removes no entry
point there.

Author: tieo

src/OpenDebugAD7/AD7Utils.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft. All rights reserved.
+// Copyright (c) Microsoft. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 using System;
@@ -20,7 +20,23 @@ public static bool IsAnnotatedFrame(ref FRAMEINFO frameInfo)
 
         public static string GetMemoryReferenceFromIDebugProperty(IDebugProperty2 property)
         {
-            if (property != null && property.GetMemoryContext(out IDebugMemoryContext2 memoryContext) == HRConstants.S_OK)
+            if (property == null)
+            {
+                return null;
+            }
+
+            // Only a pointer or an array holds an address a memoryReference can point at.
+            // For any other type the value is not an address, so a memoryReference would
+            // make the client show a memory view that navigates to the value itself. The
+            // engine's GetMemoryContext still resolves an address for any type, which the
+            // Visual Studio Memory and Disassembly windows rely on; the restriction here
+            // applies only to the reference reported over DAP.
+            if (!IsPointerOrArray(property))
+            {
+                return null;
+            }
+
+            if (property.GetMemoryContext(out IDebugMemoryContext2 memoryContext) == HRConstants.S_OK)
             {
                 CONTEXT_INFO[] contextInfo = new CONTEXT_INFO[1];
                 if (memoryContext.GetInfo(enum_CONTEXT_INFO_FIELDS.CIF_ADDRESS, contextInfo) == HRConstants.S_OK)
@@ -34,5 +50,29 @@ public static string GetMemoryReferenceFromIDebugProperty(IDebugProperty2 proper
 
             return null;
         }
+
+        private static bool IsPointerOrArray(IDebugProperty2 property)
+        {
+            DEBUG_PROPERTY_INFO[] propertyInfo = new DEBUG_PROPERTY_INFO[1];
+            if (property.GetPropertyInfo(enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE, Constants.EvaluationRadix, Constants.EvaluationTimeout, null, 0, propertyInfo) != HRConstants.S_OK)
+            {
+                return false;
+            }
+
+            if (!propertyInfo[0].dwFields.HasFlag(enum_DEBUGPROP_INFO_FLAGS.DEBUGPROP_INFO_TYPE))
+            {
+                return false;
+            }
+
+            string typeName = propertyInfo[0].bstrType;
+            if (string.IsNullOrEmpty(typeName))
+            {
+                return false;
+            }
+
+            typeName = typeName.TrimEnd();
+            return typeName.EndsWith("*", StringComparison.Ordinal)   // pointer, e.g. "int *"
+                || typeName.EndsWith("]", StringComparison.Ordinal);  // array, e.g. "int [10]"
+        }
     }
 }