Distinct type option filter entry fixes, Include Filtered fix

IDEHelper/Compiler/BfAutoComplete.cpp

@@ -427,7 +427,10 @@ BfTypedValue BfAutoComplete::LookupTypeRefOrIdentifier(BfAstNode* node, bool* is
 			}
 		}
 
-		auto type = mModule->ResolveTypeRef(typeRef);
+		BfResolveTypeRefFlags resolveTypeRefFlags = BfResolveTypeRefFlag_AllowUnboundGeneric;
+		if (mResolveType == BfResolveType_VerifyTypeName)
+			resolveTypeRefFlags = (BfResolveTypeRefFlags)(resolveTypeRefFlags | BfResolveTypeRefFlag_ForceUnboundGeneric);
+		BfType* type = mModule->ResolveTypeRef(typeRef, BfPopulateType_Identity, resolveTypeRefFlags);
 		if (type != NULL)
 		{
 			*isStatic = true;

IDEHelper/Compiler/BfCompiler.cpp

@@ -9211,6 +9211,7 @@ BF_EXPORT bool BF_CALLTYPE BfCompiler_VerifyTypeName(BfCompiler* bfCompiler, cha
 		resolvePassData.mResolveType = BfResolveType_Autocomplete;
 		parser.mParserFlags = (BfParserFlag)(parser.mParserFlags | ParserFlag_Autocomplete);		
 		resolvePassData.mAutoComplete = new BfAutoComplete();		
+		resolvePassData.mAutoComplete->mResolveType = BfResolveType_VerifyTypeName;
 		resolvePassData.mAutoComplete->mSystem = bfCompiler->mSystem;
 		resolvePassData.mAutoComplete->mCompiler = bfCompiler;
 		resolvePassData.mAutoComplete->mModule = bfCompiler->mContext->mScratchModule;

IDEHelper/Compiler/BfExprEvaluator.cpp

@@ -10969,17 +10969,13 @@ void BfExprEvaluator::Visit(BfTypeOfExpression* typeOfExpr)
 	}
 
 	BfType* type;
-	if (auto genericTypeRef = BfNodeDynCast<BfGenericInstanceTypeRef>(typeOfExpr->mTypeRef))
+	if ((typeOfExpr->mTypeRef != NULL) && (typeOfExpr->mTypeRef->IsA<BfVarTypeReference>()))
-	{
-		type = mModule->ResolveTypeRefAllowUnboundGenerics(typeOfExpr->mTypeRef, BfPopulateType_Identity);
-	}
-	else if ((typeOfExpr->mTypeRef != NULL) && (typeOfExpr->mTypeRef->IsA<BfVarTypeReference>()))
 	{
 		type = mModule->GetPrimitiveType(BfTypeCode_Var);
 	}
 	else
 	{
-		type = ResolveTypeRef(typeOfExpr->mTypeRef, BfPopulateType_Identity, BfResolveTypeRefFlag_AllowGlobalsSelf);
+		type = ResolveTypeRef(typeOfExpr->mTypeRef, BfPopulateType_Identity, (BfResolveTypeRefFlags)(BfResolveTypeRefFlag_AllowGlobalsSelf | BfResolveTypeRefFlag_AllowUnboundGeneric));
 	}
 	
 	if (type == NULL)

IDEHelper/Compiler/BfModuleTypeUtils.cpp

@@ -1877,6 +1877,7 @@ int BfModule::GenerateTypeOptions(BfCustomAttributes* customAttributes, BfTypeIn
 		auto _CheckType = [&](BfType* type)
 		{			
 			StringImpl typeName = TypeToString(type);
+
 			for (int optionIdx = 0; optionIdx < (int)mContext->mSystem->mTypeOptions.size(); optionIdx++)
 			{
 				auto& typeOptions = mContext->mSystem->mTypeOptions[optionIdx];
@@ -5684,9 +5685,7 @@ void BfModule::DoTypeInstanceMethodProcessing(BfTypeInstance* typeInstance)
 			if (((typeInstance->mAlwaysIncludeFlags & BfAlwaysIncludeFlag_AssumeInstantiated) != 0) &&
 				(methodDef->IsDefaultCtor()))
 				implRequired = true;
-
+			
-			if ((typeOptionsIncludeAll) && (ApplyTypeOptionMethodFilters(true, methodDef, typeOptions)))
-
 			if ((typeOptionsIncludeAll || typeOptionsIncludeFiltered) && (ApplyTypeOptionMethodFilters(typeOptionsIncludeAll, methodDef, typeOptions)))
 				implRequired = true;
 
@@ -9511,49 +9510,93 @@ bool BfModule::ValidateTypeWildcard(BfAstNode* typeRef, bool isAttributeRef)
 	{
 		if (qualifiedTypeRef->mLeft == NULL)
 			return false;
-
+		
-		StringT<128> leftNameStr;
-
-		BfType* leftType = NULL;
-		BfAtomComposite leftComposite;
-
-		qualifiedTypeRef->mLeft->ToString(leftNameStr);
-		if (!mSystem->ParseAtomComposite(leftNameStr, leftComposite))
-			return false;
-
 		if (auto wildcardTypeRef = BfNodeDynCast<BfWildcardTypeReference>(qualifiedTypeRef->mRight))
 		{
+			StringT<128> leftNameStr;
+
+			BfType* leftType = NULL;
+			BfAtomComposite leftComposite;
+
+			qualifiedTypeRef->mLeft->ToString(leftNameStr);
+			if (!mSystem->ParseAtomComposite(leftNameStr, leftComposite))
+				return false;
+
 			if (mSystem->ContainsNamespace(leftComposite, NULL))
 				return true;
 
 			return ValidateTypeWildcard(qualifiedTypeRef->mLeft, false);
-		}		
+		}
+	}	
+
+	if (!BfNodeIsA<BfGenericInstanceTypeRef>(typeRef))
+	{
+		if (auto elementedTypeRef = BfNodeDynCast<BfElementedTypeRef>(typeRef))
+		{
+			return ValidateTypeWildcard(elementedTypeRef->mElementType, false);
+		}
 	}
 
-	if (auto genericTypeRef = BfNodeDynCast<BfGenericInstanceTypeRef>(typeRef))
+	BfAstNode* origTypeRef = typeRef;
+
+	String name;
+	String nameEx;
+	int genericCount = 0;
+	std::function<bool(BfAstNode*, bool)> _ToString = [&](BfAstNode* typeRef, bool isLast)
 	{
-		StringT<128> nameStr;
+		if (auto qualifiedTypeRef = BfNodeDynCast<BfQualifiedTypeReference>(typeRef))
-		genericTypeRef->mElementType->ToString(nameStr);
-
-		auto typeDef = mSystem->FindTypeDef(nameStr, (int)genericTypeRef->mGenericArguments.size(), NULL);
-		if (typeDef == NULL)		
-			return false;		
-
-		if (typeDef->mGenericParamDefs.size() != genericTypeRef->GetGenericArgCount())
-			return false;
-
-		for (auto genericArgTypeRef : genericTypeRef->mGenericArguments)
 		{
-			if ((genericTypeRef != NULL) && (!ValidateTypeWildcard(genericArgTypeRef, false)))
+			_ToString(qualifiedTypeRef->mLeft, false);
-				return false;
+			name.Append(".");
+			nameEx.Append(".");
+			_ToString(qualifiedTypeRef->mRight, typeRef == origTypeRef);
+			return true;
+		}
+
+		if (auto genericTypeRef = BfNodeDynCast<BfGenericInstanceTypeRef>(typeRef))
+		{
+			_ToString(genericTypeRef->mElementType, false);
+			genericCount += genericTypeRef->mCommas.mSize + 1;			
+			for (auto genericArg : genericTypeRef->mGenericArguments)
+				if (!ValidateTypeWildcard(genericArg, false))
+					return false;			
+		}
+		else
+		{
+			typeRef->ToString(name);
+			typeRef->ToString(nameEx);
+		}
+
+		if (genericCount > 0)
+		{
+			if (!isLast)
+				name += StrFormat("`%d", genericCount);
+			nameEx += StrFormat("`%d", genericCount);
 		}
 
 		return true;
-	}
+	};
 
-	if (auto elementedTypeRef = BfNodeDynCast<BfElementedTypeRef>(typeRef))
+	if (!_ToString(typeRef, true))
+		return false;
+
+	BfAtomComposite composite;
+	if (!mSystem->ParseAtomComposite(name, composite))
+		return false;
+
+	BfAtomComposite compositeEx;	
+	if (!mSystem->ParseAtomComposite(nameEx, compositeEx))
+		return false;
+	
+	auto itr = mSystem->mTypeDefs.TryGet(composite);
+	while (itr != mSystem->mTypeDefs.end())
 	{
-		return ValidateTypeWildcard(elementedTypeRef->mElementType, false);
+		auto typeDef = *itr;
+		if (typeDef->mFullName != composite)
+			break;
+		if (typeDef->mFullNameEx == compositeEx)
+			return true;
+		++itr;
 	}
 
 	return false;
@@ -10482,8 +10525,10 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula
 	}
 
 	BfResolvedTypeSet::LookupContext lookupCtx;
-	lookupCtx.mResolveFlags = (BfResolveTypeRefFlags)(resolveFlags & (BfResolveTypeRefFlag_NoCreate | BfResolveTypeRefFlag_IgnoreLookupError | 
+	lookupCtx.mResolveFlags = (BfResolveTypeRefFlags)(resolveFlags &
-		BfResolveTypeRefFlag_DisallowComptime | BfResolveTypeRefFlag_AllowInferredSizedArray | BfResolveTypeRefFlag_Attribute));
+		(BfResolveTypeRefFlag_NoCreate | BfResolveTypeRefFlag_IgnoreLookupError | BfResolveTypeRefFlag_DisallowComptime |
+		BfResolveTypeRefFlag_AllowInferredSizedArray | BfResolveTypeRefFlag_Attribute | BfResolveTypeRefFlag_AllowUnboundGeneric |
+			BfResolveTypeRefFlag_ForceUnboundGeneric));
 	lookupCtx.mRootTypeRef = typeRef;
 	lookupCtx.mRootTypeDef = typeDef;
 	lookupCtx.mModule = this;
@@ -10909,6 +10954,7 @@ BfType* BfModule::ResolveTypeRef(BfTypeReference* typeRef, BfPopulateType popula
 			int refHash = BfResolvedTypeSet::Hash(typeRef, &lookupCtx);
 			int typeHash = BfResolvedTypeSet::Hash(genericTypeInst, &lookupCtx);
 			BF_ASSERT(refHash == typeHash);
+			BF_ASSERT(refHash == resolvedEntry->mHash);
 		}
 		if (!BfResolvedTypeSet::Equals(genericTypeInst, typeRef, &lookupCtx))
 		{

IDEHelper/Compiler/BfResolvePass.h

@@ -22,6 +22,7 @@ enum BfResolveType
 	BfResolveType_GetTypeDefList,
 	BfResolveType_GetTypeDefInto,
 	BfResolveType_GetResultString,
+	BfResolveType_VerifyTypeName
 };
 
 class BfLocalVariable;

IDEHelper/Compiler/BfResolvedTypeUtils.cpp

@@ -3144,8 +3144,42 @@ void BfResolvedTypeSet::HashGenericArguments(BfTypeReference* typeRef, LookupCon
 
 	if (auto genericTypeRef = BfNodeDynCast<BfGenericInstanceTypeRef>(typeRef))
 	{
-		for (auto genericArg : genericTypeRef->mGenericArguments)
+		for (int genericIdx = 0; genericIdx < BF_MAX(genericTypeRef->mGenericArguments.mSize, genericTypeRef->mCommas.mSize + 1); genericIdx++)
-			hashVal = HASH_MIX(hashVal, Hash(genericArg, ctx, BfHashFlag_AllowGenericParamConstValue, hashSeed + 1));
+		{
+			BfAstNode* genericArgTypeRef = NULL;
+			if (genericIdx < genericTypeRef->mGenericArguments.mSize)			
+				genericArgTypeRef = genericTypeRef->mGenericArguments[genericIdx];			
+
+			if ((ctx->mResolveFlags & BfResolveTypeRefFlag_AllowUnboundGeneric) != 0)
+			{
+				if (BfNodeIsExact<BfWildcardTypeReference>(genericArgTypeRef))
+					genericArgTypeRef = NULL;
+			}
+
+			int argHashVal = 0;
+			if (genericArgTypeRef != NULL)
+			{
+				argHashVal = Hash(genericArgTypeRef, ctx, BfHashFlag_AllowGenericParamConstValue, hashSeed + 1);
+				if ((ctx->mResolveFlags & BfResolveTypeRefFlag_ForceUnboundGeneric) != 0)
+					genericArgTypeRef = NULL;
+			}
+
+			if (genericArgTypeRef == NULL)
+			{
+				if ((ctx->mResolveFlags & BfResolveTypeRefFlag_AllowUnboundGeneric) != 0)
+				{					
+					argHashVal = (((int)BfGenericParamKind_Type + 0xB00) << 8) ^ (genericIdx + 1);
+					argHashVal = HASH_MIX(argHashVal, hashSeed + 1);					
+				}
+				else
+				{
+					ctx->mFailed = true;
+					return;
+				}
+			}
+			
+			hashVal = HASH_MIX(hashVal, argHashVal);
+		}
 	}
 }
 
@@ -3767,6 +3801,11 @@ int BfResolvedTypeSet::DoHash(BfTypeReference* typeRef, LookupContext* ctx, BfHa
 		ctx->mFailed = true;
 		return 0;
 	}
+	else if (auto wildcardTypeRef = BfNodeDynCastExact<BfWildcardTypeReference>(typeRef))
+	{
+		ctx->mFailed = true;
+		return 0;
+	}
 	else
 	{
 		BF_FATAL("Not handled");
@@ -4033,13 +4072,45 @@ bool BfResolvedTypeSet::GenericTypeEquals(BfTypeInstance* lhsGenericType, BfType
 
 	if (auto genericTypeRef = BfNodeDynCastExact<BfGenericInstanceTypeRef>(rhs))
 	{
-		if (genericTypeRef->mGenericArguments.size() > lhsTypeGenericArguments->size() + genericParamOffset)
+		int rhsGenericArgCount = BF_MAX(genericTypeRef->mGenericArguments.mSize, genericTypeRef->mCommas.mSize + 1);
+
+		if (genericTypeRef->mGenericArguments.size() > rhsGenericArgCount + genericParamOffset)
 			return false;
 
-		for (auto genericArg : genericTypeRef->mGenericArguments)
+		for (int genericIdx = 0; genericIdx < BF_MAX(genericTypeRef->mGenericArguments.mSize, genericTypeRef->mCommas.mSize + 1); genericIdx++)
 		{
-			if (!Equals((*lhsTypeGenericArguments)[genericParamOffset++], genericArg, ctx))
+			BfType* lhsArgType = (*lhsTypeGenericArguments)[genericParamOffset++];
-				return false;
+
+			BfAstNode* genericArgTypeRef = NULL;
+			if (genericIdx < genericTypeRef->mGenericArguments.mSize)
+				genericArgTypeRef = genericTypeRef->mGenericArguments[genericIdx];
+
+			if ((ctx->mResolveFlags & BfResolveTypeRefFlag_ForceUnboundGeneric) != 0)
+			{
+				genericArgTypeRef = NULL;
+			}
+			else if ((ctx->mResolveFlags & BfResolveTypeRefFlag_AllowUnboundGeneric) != 0)
+			{
+				if (BfNodeIsExact<BfWildcardTypeReference>(genericArgTypeRef))
+					genericArgTypeRef = NULL;
+			}
+
+			if (genericArgTypeRef == NULL)
+			{
+				if (lhsArgType->IsGenericParam())
+				{
+					auto lhsGenericArgType = (BfGenericParamType*)lhsArgType;
+					if ((lhsGenericArgType->mGenericParamKind != BfGenericParamKind_Type) || (lhsGenericArgType->mGenericParamIdx != genericIdx))
+						return false;
+				}
+				else
+					return false;
+			}
+			else
+			{
+				if (!Equals(lhsArgType, genericArgTypeRef, ctx))
+					return false;
+			}			
 		}
 	}
 

IDEHelper/Compiler/BfResolvedTypeUtils.h

@@ -38,7 +38,9 @@ enum BfResolveTypeRefFlags
 	BfResolveTypeRefFlag_AllowGlobalContainer = 0x4000,
 	BfResolveTypeRefFlag_AllowInferredSizedArray = 0x8000,
 	BfResolveTypeRefFlag_AllowGlobalsSelf = 0x10000,
-	BfResolveTypeRefFlag_AllowImplicitConstExpr = 0x20000
+	BfResolveTypeRefFlag_AllowImplicitConstExpr = 0x20000,
+	BfResolveTypeRefFlag_AllowUnboundGeneric = 0x40000,
+	BfResolveTypeRefFlag_ForceUnboundGeneric = 0x80000
 };
 
 enum BfTypeNameFlags : uint16

IDEHelper/Compiler/BfSystem.cpp

@@ -2781,11 +2781,6 @@ void BfSystem::InjectNewRevision(BfTypeDef* typeDef)
 {
 	BfLogSys(this, "InjectNewRevision from %p (decl:%p) into %p (decl:%p)\n", typeDef->mNextRevision, typeDef->mNextRevision->mTypeDeclaration, typeDef, typeDef->mTypeDeclaration);
 
-	if (typeDef->mName->ToString() == "Zonk")
-	{
-		NOP;
-	}
-
 	bool setDeclaringType = !typeDef->mIsCombinedPartial;
 
 	auto nextTypeDef = typeDef->mNextRevision;