Improvements in CorDebugType and CorDebugClass (#300)

josesimoes · web-flow · commit 8f6454b7a401 · 2018-09-21T13:19:44.000+01:00
diff --git a/source/VisualStudio.Extension/CorDebug/CorDebugClass.cs b/source/VisualStudio.Extension/CorDebug/CorDebugClass.cs
@@ -21,8 +21,8 @@ public CorDebugClass(CorDebugAssembly assembly, Pdbx.Class cls)
             m_assembly = assembly;
             m_pdbxClass = cls;
         }
-        
-        public CorDebugClass (CorDebugAssembly assembly, uint tkSymbolless) : this(assembly, null)
+
+        public CorDebugClass(CorDebugAssembly assembly, uint tkSymbolless) : this(assembly, null)
         {
             m_tkSymbolless = tkSymbolless;
         }
@@ -45,10 +45,10 @@ public CorDebugAssembly Assembly
 
         public bool IsEnum
         {
-            get 
+            get
             {
-                if(HasSymbols)
-                    return MetaData.Helper.ClassIsEnum(Assembly.MetaDataImport, m_pdbxClass.Token.CLR );
+                if (HasSymbols)
+                    return MetaData.Helper.ClassIsEnum(Assembly.MetaDataImport, m_pdbxClass.Token.CLR);
                 else
                     return false;
             }
@@ -75,7 +75,7 @@ public CorDebugAppDomain AppDomain
         public Pdbx.Class PdbxClass
         {
             [DebuggerHidden]
-            get {return m_pdbxClass;}
+            get { return m_pdbxClass; }
         }
 
         public bool HasSymbols
@@ -89,27 +89,27 @@ public uint TypeDef_Index
             {
                 uint tk = HasSymbols ? m_pdbxClass.Token.nanoCLR : m_tkSymbolless;
 
-                return nanoCLR_TypeSystem.ClassMemberIndexFromnanoCLRToken (tk, Assembly);                
+                return nanoCLR_TypeSystem.ClassMemberIndexFromnanoCLRToken(tk, Assembly);
             }
         }
 
         #region ICorDebugClass Members
 
-        int ICorDebugClass. GetModule (out ICorDebugModule pModule)
+        int ICorDebugClass.GetModule(out ICorDebugModule pModule)
         {
             pModule = m_assembly;
 
             return COM_HResults.S_OK;
         }
 
-        int ICorDebugClass. GetToken (out uint pTypeDef)
+        int ICorDebugClass.GetToken(out uint pTypeDef)
         {
             pTypeDef = HasSymbols ? m_pdbxClass.Token.CLR : m_tkSymbolless;
 
             return COM_HResults.S_OK;
         }
 
-        int ICorDebugClass. GetStaticFieldValue (uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue)
+        int ICorDebugClass.GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue)
         {
             //Cache, and invalidate when necessary???
             uint fd = nanoCLR_TypeSystem.ClassMemberIndexFromCLRToken(fieldDef, Assembly);
@@ -125,15 +125,14 @@ int ICorDebugClass. GetStaticFieldValue (uint fieldDef, ICorDebugFrame pFrame, o
 
         #region ICorDebugClass2 Members
 
-        int ICorDebugClass2.GetParameterizedType( CorElementType elementType, uint nTypeArgs, ICorDebugType []ppTypeArgs, out ICorDebugType ppType )
+        int ICorDebugClass2.GetParameterizedType(CorElementType elementType, uint nTypeArgs, ICorDebugType[] ppTypeArgs, out ICorDebugType ppType)
         {
-            // CorDebugClass.GetParameterizedType is not implemented
-            ppType = null;
+            ppType = new CorDebugGenericType(elementType, null, Assembly);
 
             return COM_HResults.S_OK;
         }
 
-        int ICorDebugClass2. SetJMCStatus (int bIsJustMyCode)
+        int ICorDebugClass2.SetJMCStatus(int bIsJustMyCode)
         {
             bool fJMC = Boolean.IntToBool(bIsJustMyCode);
 
@@ -145,12 +144,12 @@ int ICorDebugClass2. SetJMCStatus (int bIsJustMyCode)
             {
                 if (Engine.Info_SetJMC(fJMC, ReflectionDefinition.Kind.REFLECTION_TYPE, TypeDef_Index))
                 {
-                    if(!m_assembly.IsFrameworkAssembly)
+                    if (!m_assembly.IsFrameworkAssembly)
                     {
                         //now update the debugger JMC state...
                         foreach (Pdbx.Method m in m_pdbxClass.Methods)
-                        {                    
-                            m.IsJMC = fJMC;                    
+                        {
+                            m.IsJMC = fJMC;
                         }
                     }
 
@@ -161,6 +160,6 @@ int ICorDebugClass2. SetJMCStatus (int bIsJustMyCode)
             return hres;
         }
 
-#endregion
+        #endregion
     }
 }
diff --git a/source/VisualStudio.Extension/CorDebug/CorDebugType.cs b/source/VisualStudio.Extension/CorDebug/CorDebugType.cs
@@ -15,33 +15,33 @@ namespace nanoFramework.Tools.VisualStudio.Extension
     public class CorDebugTypeArray : ICorDebugType
     {
         CorDebugValueArray m_ValueArray;
-        
-        public CorDebugTypeArray( CorDebugValueArray valArray )
+
+        public CorDebugTypeArray(CorDebugValueArray valArray)
         {
-            m_ValueArray = valArray; 
+            m_ValueArray = valArray;
         }
 
-        int ICorDebugType.EnumerateTypeParameters (out ICorDebugTypeEnum ppTyParEnum)
+        int ICorDebugType.EnumerateTypeParameters(out ICorDebugTypeEnum ppTyParEnum)
         {
             ppTyParEnum = null;
             return COM_HResults.E_NOTIMPL;
         }
 
-        int ICorDebugType.GetType (out CorElementType ty)
+        int ICorDebugType.GetType(out CorElementType ty)
         {
             // This is for arrays. ELEMENT_TYPE_SZARRAY - means single demensional array.
             ty = CorElementType.ELEMENT_TYPE_SZARRAY;
             return COM_HResults.S_OK;
         }
 
-        int ICorDebugType.GetRank (out uint pnRank)
+        int ICorDebugType.GetRank(out uint pnRank)
         {
             // ELEMENT_TYPE_SZARRAY - means single demensional array.
             pnRank = 1;
             return COM_HResults.S_OK;
         }
 
-        int ICorDebugType.GetClass (out ICorDebugClass ppClass)
+        int ICorDebugType.GetClass(out ICorDebugClass ppClass)
         {
             ppClass = CorDebugValue.ClassFromRuntimeValue(m_ValueArray.RuntimeValue, m_ValueArray.AppDomain);
             return COM_HResults.S_OK;
@@ -52,19 +52,19 @@ int ICorDebugType.GetClass (out ICorDebugClass ppClass)
          *  of element in the array.
          *  It control viewing of arrays elements in the watch window of debugger.
          */
-        int ICorDebugType.GetFirstTypeParameter (out ICorDebugType value)
+        int ICorDebugType.GetFirstTypeParameter(out ICorDebugType value)
         {
             value = new CorDebugGenericType(CorElementType.ELEMENT_TYPE_CLASS, m_ValueArray.RuntimeValue, m_ValueArray.AppDomain);
             return COM_HResults.S_OK;
         }
 
-        int ICorDebugType.GetStaticFieldValue (uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue)
-        {            
+        int ICorDebugType.GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue)
+        {
             ppValue = null;
             return COM_HResults.E_NOTIMPL;
         }
 
-        int ICorDebugType.GetBase (out ICorDebugType pBase)
+        int ICorDebugType.GetBase(out ICorDebugType pBase)
         {
             pBase = null;
             return COM_HResults.E_NOTIMPL;
@@ -77,11 +77,55 @@ public class CorDebugGenericType : ICorDebugType
         public RuntimeValue m_rtv;
         public CorDebugAppDomain m_appDomain;
 
+        public CorDebugAssembly Assembly
+        {
+            [System.Diagnostics.DebuggerHidden]
+            get;
+        }
+
+        public Engine Engine
+        {
+            [System.Diagnostics.DebuggerHidden]
+            get { return this.Process?.Engine; }
+        }
+
+        public CorDebugProcess Process
+        {
+            [System.Diagnostics.DebuggerHidden]
+            get { return this.Assembly?.Process; }
+        }
+
+        public CorDebugAppDomain AppDomain
+        {
+            [System.Diagnostics.DebuggerHidden]
+            get
+            {
+                if (m_appDomain != null)
+                {
+                    return m_appDomain;
+                }
+                else
+                {
+                    return this.Assembly?.AppDomain;
+                }
+            }
+        }
+
+        // This is used to resolve values into types when we know the appdomain, but not the assembly.
         public CorDebugGenericType(CorElementType elemType, RuntimeValue rtv, CorDebugAppDomain appDomain)
-        { 
+        {
             m_elemType = elemType;
             m_rtv = rtv;
-            m_appDomain = appDomain; 
+            m_appDomain = appDomain;
+        }
+
+        // This constructor is used exclusively for resolving potentially (but never really) generic classes into fully specified types.
+        // Generics are not supported (yet) but we still need to be able to convert classes into fully specified types.      
+        public CorDebugGenericType(CorElementType elemType, RuntimeValue rtv, CorDebugAssembly assembly)
+        {
+            m_elemType = elemType;
+            m_rtv = rtv;
+            Assembly = assembly;
         }
 
         int ICorDebugType.EnumerateTypeParameters(out ICorDebugTypeEnum ppTyParEnum)
@@ -106,7 +150,7 @@ int ICorDebugType.GetRank(out uint pnRank)
 
         int ICorDebugType.GetClass(out ICorDebugClass ppClass)
         {
-            ppClass = CorDebugValue.ClassFromRuntimeValue(m_rtv, m_appDomain);
+            ppClass = CorDebugValue.ClassFromRuntimeValue(m_rtv, AppDomain);
             return COM_HResults.S_OK;
         }
 
@@ -119,8 +163,13 @@ int ICorDebugType.GetFirstTypeParameter(out ICorDebugType value)
 
         int ICorDebugType.GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue)
         {
-            ppValue = null;
-            return COM_HResults.E_NOTIMPL;
+            uint fd = nanoCLR_TypeSystem.ClassMemberIndexFromCLRToken(fieldDef, this.Assembly);
+
+            this.Process.SetCurrentAppDomain(this.AppDomain);
+            RuntimeValue rtv = this.Engine.GetStaticFieldValue(fd);
+            ppValue = CorDebugValue.CreateValue(rtv, this.AppDomain);
+
+            return COM_HResults.S_OK;
         }
 
         int ICorDebugType.GetBase(out ICorDebugType pBase)

Original file line number	Diff line number	Diff line change
`@@ -21,8 +21,8 @@ public CorDebugClass(CorDebugAssembly assembly, Pdbx.Class cls)`
`21`	`21`	`m_assembly = assembly;`
`22`	`22`	`m_pdbxClass = cls;`
`23`	`23`	`}`
`24`		`-`
`25`		`- public CorDebugClass (CorDebugAssembly assembly, uint tkSymbolless) : this(assembly, null)`
	`24`	`+`
	`25`	`+ public CorDebugClass(CorDebugAssembly assembly, uint tkSymbolless) : this(assembly, null)`
`26`	`26`	`{`
`27`	`27`	`m_tkSymbolless = tkSymbolless;`
`28`	`28`	`}`
`@@ -45,10 +45,10 @@ public CorDebugAssembly Assembly`
`45`	`45`
`46`	`46`	`public bool IsEnum`
`47`	`47`	`{`
`48`		`- get`
	`48`	`+ get`
`49`	`49`	`{`
`50`		`- if(HasSymbols)`
`51`		`- return MetaData.Helper.ClassIsEnum(Assembly.MetaDataImport, m_pdbxClass.Token.CLR );`
	`50`	`+ if (HasSymbols)`
	`51`	`+ return MetaData.Helper.ClassIsEnum(Assembly.MetaDataImport, m_pdbxClass.Token.CLR);`
`52`	`52`	`else`
`53`	`53`	`return false;`
`54`	`54`	`}`
`@@ -75,7 +75,7 @@ public CorDebugAppDomain AppDomain`
`75`	`75`	`public Pdbx.Class PdbxClass`
`76`	`76`	`{`
`77`	`77`	`[DebuggerHidden]`
`78`		`- get {return m_pdbxClass;}`
	`78`	`+ get { return m_pdbxClass; }`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`public bool HasSymbols`
`@@ -89,27 +89,27 @@ public uint TypeDef_Index`
`89`	`89`	`{`
`90`	`90`	`uint tk = HasSymbols ? m_pdbxClass.Token.nanoCLR : m_tkSymbolless;`
`91`	`91`
`92`		`- return nanoCLR_TypeSystem.ClassMemberIndexFromnanoCLRToken (tk, Assembly);`
	`92`	`+ return nanoCLR_TypeSystem.ClassMemberIndexFromnanoCLRToken(tk, Assembly);`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`#region ICorDebugClass Members`
`97`	`97`
`98`		`- int ICorDebugClass. GetModule (out ICorDebugModule pModule)`
	`98`	`+ int ICorDebugClass.GetModule(out ICorDebugModule pModule)`
`99`	`99`	`{`
`100`	`100`	`pModule = m_assembly;`
`101`	`101`
`102`	`102`	`return COM_HResults.S_OK;`
`103`	`103`	`}`
`104`	`104`
`105`		`- int ICorDebugClass. GetToken (out uint pTypeDef)`
	`105`	`+ int ICorDebugClass.GetToken(out uint pTypeDef)`
`106`	`106`	`{`
`107`	`107`	`pTypeDef = HasSymbols ? m_pdbxClass.Token.CLR : m_tkSymbolless;`
`108`	`108`
`109`	`109`	`return COM_HResults.S_OK;`
`110`	`110`	`}`
`111`	`111`
`112`		`- int ICorDebugClass. GetStaticFieldValue (uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue)`
	`112`	`+ int ICorDebugClass.GetStaticFieldValue(uint fieldDef, ICorDebugFrame pFrame, out ICorDebugValue ppValue)`
`113`	`113`	`{`
`114`	`114`	`//Cache, and invalidate when necessary???`
`115`	`115`	`uint fd = nanoCLR_TypeSystem.ClassMemberIndexFromCLRToken(fieldDef, Assembly);`
`@@ -125,15 +125,14 @@ int ICorDebugClass. GetStaticFieldValue (uint fieldDef, ICorDebugFrame pFrame, o`
`125`	`125`
`126`	`126`	`#region ICorDebugClass2 Members`
`127`	`127`
`128`		`- int ICorDebugClass2.GetParameterizedType( CorElementType elementType, uint nTypeArgs, ICorDebugType []ppTypeArgs, out ICorDebugType ppType )`
	`128`	`+ int ICorDebugClass2.GetParameterizedType(CorElementType elementType, uint nTypeArgs, ICorDebugType[] ppTypeArgs, out ICorDebugType ppType)`
`129`	`129`	`{`
`130`		`- // CorDebugClass.GetParameterizedType is not implemented`
`131`		`- ppType = null;`
	`130`	`+ ppType = new CorDebugGenericType(elementType, null, Assembly);`
`132`	`131`
`133`	`132`	`return COM_HResults.S_OK;`
`134`	`133`	`}`
`135`	`134`
`136`		`- int ICorDebugClass2. SetJMCStatus (int bIsJustMyCode)`
	`135`	`+ int ICorDebugClass2.SetJMCStatus(int bIsJustMyCode)`
`137`	`136`	`{`
`138`	`137`	`bool fJMC = Boolean.IntToBool(bIsJustMyCode);`
`139`	`138`
`@@ -145,12 +144,12 @@ int ICorDebugClass2. SetJMCStatus (int bIsJustMyCode)`
`145`	`144`	`{`
`146`	`145`	`if (Engine.Info_SetJMC(fJMC, ReflectionDefinition.Kind.REFLECTION_TYPE, TypeDef_Index))`
`147`	`146`	`{`
`148`		`- if(!m_assembly.IsFrameworkAssembly)`
	`147`	`+ if (!m_assembly.IsFrameworkAssembly)`
`149`	`148`	`{`
`150`	`149`	`//now update the debugger JMC state...`
`151`	`150`	`foreach (Pdbx.Method m in m_pdbxClass.Methods)`
`152`		`- {`
`153`		`- m.IsJMC = fJMC;`
	`151`	`+ {`
	`152`	`+ m.IsJMC = fJMC;`
`154`	`153`	`}`
`155`	`154`	`}`
`156`	`155`
`@@ -161,6 +160,6 @@ int ICorDebugClass2. SetJMCStatus (int bIsJustMyCode)`
`161`	`160`	`return hres;`
`162`	`161`	`}`
`163`	`162`
`164`		`-#endregion`
	`163`	`+ #endregion`
`165`	`164`	`}`
`166`	`165`	`}`