Unspec variation base fix, debugger default params, debug enum type

IDE/Tests/Test1/scripts/Methods.txt

@@ -12,6 +12,7 @@ AssertEvalEquals("ClassA.TEST_StaticMethodA()", "100")
 AssertEvalContains("ClassA.TEST_StaticMethodB()", "Unable to find address for method")
 AssertAutocompleteEquals("ClassA.TEST_", "TEST_StaticMethodA\nTEST_StaticMethodB")
 AssertAutocompleteEquals("ca.TEST_", "TEST_MethodA\nTEST_MethodB")
+AssertEvalEquals("Test0(EnumA.C, 200)", "1202")
 NavigateBackwards()
 
 ToggleCommentAt("ClassA_MethodC")

IDE/Tests/Test1/src/Methods.bf

@@ -50,6 +50,20 @@ namespace IDETest
 			*/
 		}
 
+		enum EnumA
+		{
+			case A;
+			case B;
+			case C;
+
+			public const EnumA D = (EnumA)4;
+		}
+
+		static int Test0(EnumA a, int b, int c = 1000)
+		{
+			return (int)a + (int)b + (int)c;
+		}
+
 		public static void Test()
 		{
 			//Test_Start
@@ -57,6 +71,7 @@ namespace IDETest
 			ca.TEST_MethodA();
 			ClassA.TEST_StaticMethodA();
 			DoTest();
+			Test0(.A, 1, 2);
 		}
 	}
 }

IDEHelper/Compiler/BfCompiler.cpp

@@ -2321,7 +2321,7 @@ void BfCompiler::UpdateDependencyMap(bool deleteUnusued, bool& didWork)
 						auto dependentType = itr->mKey;							
 						if (dependentType->IsIncomplete())
 						{								
-							BF_ASSERT(dependentType->IsDeleting() || dependentType->IsOnDemand() || !dependentType->HasBeenReferenced() || !madeFullPass || dependentType->IsSpecializedByAutoCompleteMethod());
+							BF_ASSERT(dependentType->IsDeleting() || dependentType->IsOnDemand() || !dependentType->HasBeenReferenced() || mCanceling || !madeFullPass || dependentType->IsSpecializedByAutoCompleteMethod());
 						}
 					}
 #endif

IDEHelper/Compiler/BfIRBuilder.cpp

@@ -3206,12 +3206,7 @@ void BfIRBuilder::CreateDbgTypeDefinition(BfType* type)
 						if (fieldInstance->mResolvedType->IsComposite())
 							PopulateType(fieldInstance->mResolvedType);
 
-						BfIRMDNode constDIType;
+						BfIRMDNode constDIType = DbgCreateConstType(resolvedFieldDIType);
-						if (resolvedFieldType->IsTypedPrimitive())
-							constDIType = DbgGetType(resolvedFieldType->GetUnderlyingType());//resolvedFieldType->GetUnderlyingType()->mDIType ;
-						else
-							constDIType = DbgCreateConstType(resolvedFieldDIType);
-
 						if ((fieldDef->mIsExtern) && (resolvedFieldType->IsPointer()))
 						{
 							auto underlyingType = resolvedFieldType->GetUnderlyingType();

IDEHelper/Compiler/BfModule.cpp

@@ -20320,6 +20320,27 @@ void BfModule::ProcessMethod(BfMethodInstance* methodInstance, bool isInlineDup,
 				
 				if (!paramVar->mIsSplat)
 				{
+					if ((paramVar->mParamIdx >= 0) && (paramVar->mParamIdx < methodInstance->mDefaultValues.mSize))
+					{
+						auto defaultValue = methodInstance->mDefaultValues[paramVar->mParamIdx];
+						auto constant = mCurTypeInstance->mConstHolder->GetConstant(defaultValue.mValue);
+						if ((constant != NULL) &&
+							((BfIRConstHolder::IsIntable(constant->mTypeCode)) || (BfIRConstHolder::IsFloat(constant->mTypeCode))))
+						{
+							int64 writeVal = constant->mInt64;
+							if (constant->mTypeCode == BfTypeCode_Float)
+							{
+								// We need to do this because Singles are stored in mDouble, so we need to reduce here
+								float floatVal = (float)constant->mDouble;
+								writeVal = *(uint32*)&floatVal;
+							}
+							if (writeVal < 0)
+								paramName += StrFormat("$_%llu", -writeVal);
+							else
+								paramName += StrFormat("$%llu", writeVal);
+						}
+					}
+
 					if (paramVar->mResolvedType->IsValuelessType())
 					{
 						diVariable = mBfIRBuilder->DbgCreateAutoVariable(diFunction,
@@ -23787,6 +23808,10 @@ void BfModule::DoMethodDeclaration(BfMethodDeclaration* methodDeclaration, bool
 			addToWorkList = false;
 		}
 	}
+	else
+	{
+		GetMethodCustomAttributes(methodInstance);
+	}
 
 	auto func = methodInstance->mIRFunction;
 
@@ -24379,11 +24404,28 @@ bool BfModule::SlotVirtualMethod(BfMethodInstance* methodInstance, BfAmbiguityCo
 					if ((!checkMethodDef->mIsVirtual) || (checkMethodDef->mIsOverride))
 						continue;
 
+					BfMethodInstance* baseMethodInstance = NULL;
+
+					int checkMethodIdx = -1;
 					BfMethodInstance* lookupMethodInstance = lookupType->mMethodInstanceGroups[checkMethodDef->mIdx].mDefault;
 					if ((lookupMethodInstance == NULL) || (lookupMethodInstance->mVirtualTableIdx == -1))
-						continue;
+					{
+						if (lookupType->IsUnspecializedTypeVariation())
+						{
+							if (!lookupMethodInstance->mMethodDef->mIsOverride)
+							{
+								baseMethodInstance = lookupMethodInstance;
+								checkMethodIdx = -2;
+							}
+						}
 
-					int checkMethodIdx = lookupMethodInstance->mVirtualTableIdx;
+						if (baseMethodInstance == NULL)
+							continue;
+					}
+
+					if (baseMethodInstance == NULL)
+					{
+						checkMethodIdx = lookupMethodInstance->mVirtualTableIdx;
 						if (checkMethodIdx >= baseVirtualMethodTable.mSize)
 							FatalError("SlotVirtualMethod OOB in baseVirtualMethodTable[checkMethodIdx]");
 						auto& baseMethodRef = baseVirtualMethodTable[checkMethodIdx];
@@ -24393,19 +24435,22 @@ bool BfModule::SlotVirtualMethod(BfMethodInstance* methodInstance, BfAmbiguityCo
 							continue;
 						}
 
-					BfMethodInstance* baseMethodInstance = baseVirtualMethodTable[checkMethodIdx].mDeclaringMethod;
+						baseMethodInstance = baseVirtualMethodTable[checkMethodIdx].mDeclaringMethod;
 						if (baseMethodInstance == NULL)
 						{
 							AssertErrorState();
 							continue;
 						}
+					}
 
 					if ((baseMethodInstance != NULL) && (CompareMethodSignatures(baseMethodInstance, methodInstance)))
 					{
 						if (methodDef->mIsOverride)
 						{
 							BfMethodInstance* checkMethodInstance;
-							if (typeInstance->IsValueType())
+							if (checkMethodIdx == -2)
+								checkMethodInstance = baseMethodInstance;
+							else if (typeInstance->IsValueType())
 								checkMethodInstance = checkBase->mVirtualMethodTable[checkMethodIdx].mDeclaringMethod;
 							else
 								checkMethodInstance = typeInstance->mVirtualMethodTable[checkMethodIdx].mDeclaringMethod;
@@ -24559,7 +24604,15 @@ bool BfModule::SlotVirtualMethod(BfMethodInstance* methodInstance, BfAmbiguityCo
 					}
 				}
 			}
+		}
 
+		if (bestOverrideMethodIdx == -2)
+		{
+			// Comes from an unspecialized variation
+			virtualMethodMatchIdx = bestOverrideMethodIdx;
+		}
+		else if ((bestOverrideMethodInstance != NULL) && (bestOverrideMethodIdx != -1))
+		{
 			auto& baseVirtualMethodTable = checkBase->mVirtualMethodTable;
 			BfMethodInstance* baseVirtualMethodInstance = baseVirtualMethodTable[bestOverrideMethodIdx].mDeclaringMethod;
 			if ((baseVirtualMethodInstance != methodInstance) && (methodDef->mIsOverride))

IDEHelper/Compiler/BfModuleTypeUtils.cpp

@@ -3290,9 +3290,9 @@ void BfModule::DoPopulateType_FinishEnum(BfTypeInstance* typeInstance, bool unde
 		{
 			auto fieldInstance = &fieldInstanceRef;
 			auto fieldDef = fieldInstance->GetFieldDef();
-			if ((fieldDef != NULL) && (fieldDef->IsEnumCaseEntry()))
+			if (fieldDef != NULL)
 			{
-				if (fieldInstance->mConstIdx == -1)
+				if ((fieldInstance->mConstIdx == -1) || (fieldInstance->mResolvedType != typeInstance))
 					continue;
 
 				auto constant = typeInstance->mConstHolder->GetConstantById(fieldInstance->mConstIdx);
@@ -3343,9 +3343,7 @@ void BfModule::DoPopulateType_FinishEnum(BfTypeInstance* typeInstance, bool unde
 				for (auto& fieldInstanceRef : typeInstance->mFieldInstances)
 				{
 					auto fieldInstance = &fieldInstanceRef;
-					if (fieldInstance->mConstIdx == -1)
+					if ((fieldInstance->mConstIdx == -1) || (fieldInstance->mResolvedType != typeInstance))
-						continue;
-					if (!fieldInstance->GetFieldDef()->IsEnumCaseEntry())
 						continue;
 					auto constant = typeInstance->mConstHolder->GetConstantById(fieldInstance->mConstIdx);
 					if (constant->mTypeCode == typeCode)

IDEHelper/Compiler/CeMachine.cpp

@@ -1586,6 +1586,7 @@ void CeBuilder::Build()
 				BfMethodInstance dupUnspecMethodInstance;
 				dupUnspecMethodInstance.CopyFrom(unspecializedMethodInstance);
 				ProcessMethod(unspecializedMethodInstance, &dupUnspecMethodInstance, false);
+				if (dupUnspecMethodInstance.mMethodInfoEx != NULL)
 					dupMethodInstance.GetMethodInfoEx()->mGenericTypeBindings = dupUnspecMethodInstance.mMethodInfoEx->mGenericTypeBindings;
 			}
 		}

IDEHelper/DbgExprEvaluator.cpp

@@ -7246,9 +7246,16 @@ DbgTypedValue DbgExprEvaluator::CreateCall(BfAstNode* targetSrc, DbgTypedValue t
 		}
 
 		BfExpression* arg = NULL;
+		DbgTypedValue argValue;
 		if (argIdx < (int) arguments.size())
 		{
 			arg = arguments[argIdx];
+			argValue = argValues[argIdx];
+		}
+		else if (param->mIsConst)
+		{
+			argValue.mType = param->mType;
+			argValue.mInt64 = param->mConstValue;
 		}
 		else if (mPassInstance != NULL)
 		{
@@ -7276,7 +7283,7 @@ DbgTypedValue DbgExprEvaluator::CreateCall(BfAstNode* targetSrc, DbgTypedValue t
 			continue;
 		}
 
-		auto argValue = argValues[argIdx];
+		
 		if (argValue.mType == NULL)
 			return DbgTypedValue();
 

IDEHelper/Tests/src/Generics2.bf

@@ -5,6 +5,22 @@ namespace Tests
 {
 	class Generics2
 	{
+		class ClassA<T, T2>
+		{
+			public virtual int32 GetWidth()
+			{
+				return 123;
+			}
+		}
+
+		class ClassB<T> : ClassA<T, T>
+		{
+			public override int32 GetWidth()
+			{
+				return base.GetWidth();
+			}
+		}
+
 		struct TestFunc<T, Del>
 		{
 			private int mId;