Fixed some unknown-sized array resolution issues

IDEHelper/Compiler/BfExprEvaluator.cpp

@@ -508,10 +508,10 @@ bool BfGenericInferContext::InferGenericArgument(BfMethodInstance* methodInstanc
 		return InferGenericArgument(methodInstance, argPointerType->mElementType, wantPointerType->mElementType, BfIRValue());		
 	}
 
-	if (wantType->IsUnknownSizedArray())
+	if (wantType->IsUnknownSizedArrayType())
 	{
 		auto wantArrayType = (BfUnknownSizedArrayType*)wantType;		
-		if (argType->IsUnknownSizedArray())
+		if (argType->IsUnknownSizedArrayType())
 		{
 			auto argArrayType = (BfUnknownSizedArrayType*)argType;
 			InferGenericArgument(methodInstance, argArrayType->mElementCountSource, wantArrayType->mElementCountSource, BfIRValue());
@@ -5002,7 +5002,7 @@ BfTypedValue BfExprEvaluator::CreateCall(BfAstNode* targetSrc, BfMethodInstance*
 		{
 			if (methodInstance->mReturnType->IsInstanceOf(mModule->mCompiler->mSpanTypeDef))
 			{
-				if (mExpectingType->IsSizedArray())
+				if ((mExpectingType != NULL) && (mExpectingType->IsSizedArray()))
 				{
 					return BfTypedValue(mModule->mBfIRBuilder->GetUndefConstValue(mModule->mBfIRBuilder->MapType(mExpectingType)), mExpectingType);
 				}
@@ -18478,8 +18478,8 @@ void BfExprEvaluator::Visit(BfIndexerExpression* indexerExpr)
 			mModule->MakeAddressable(target);
 
 		mModule->PopulateType(underlyingType);
-		if ((sizedArrayType->IsUnknownSizedArray()) || (isUndefIndex))
-		{			
+		if ((sizedArrayType->IsUndefSizedArray()) || (isUndefIndex))
+		{
 			mResult = mModule->GetDefaultTypedValue(underlyingType, false, BfDefaultValueKind_Addr);
 		}
 		else if (sizedArrayType->IsValuelessType())				

IDEHelper/Compiler/BfMangler.cpp

@@ -1668,7 +1668,7 @@ void BfMSMangler::Mangle(MangleContext& mangleContext, StringImpl& name, BfType*
 	}
 	else if (type->IsSizedArray())
 	{
-		if (type->IsUnknownSizedArray())
+		if (type->IsUnknownSizedArrayType())
 		{
 			auto arrType = (BfUnknownSizedArrayType*)type;
 			name += StrFormat("arr_$", arrType->mSize);

IDEHelper/Compiler/BfModule.cpp

@@ -3774,7 +3774,7 @@ void BfModule::ResolveConstField(BfTypeInstance* typeInstance, BfFieldInstance*
 
 		auto prevInsertBlock = mBfIRBuilder->GetInsertBlock();
 
-		if (fieldType->IsVar())
+		if ((fieldType->IsVar()) || (fieldType->IsUndefSizedArray()))
 		{
 			auto initValue = GetFieldInitializerValue(fieldInstance, fieldDef->mInitializer, fieldDef, fieldType);
 			if (!initValue)
@@ -3784,7 +3784,15 @@ void BfModule::ResolveConstField(BfTypeInstance* typeInstance, BfFieldInstance*
 			}
 			if (fieldInstance != NULL)
 			{
-				fieldInstance->mResolvedType = initValue.mType;
+				if (fieldType->IsUndefSizedArray())
+				{
+					if ((initValue.mType->IsSizedArray()) && (initValue.mType->GetUnderlyingType() == fieldType->GetUnderlyingType()))
+					{
+						fieldInstance->mResolvedType = initValue.mType;
+					}
+				}
+				else
+					fieldInstance->mResolvedType = initValue.mType;
 			}
 			constValue = initValue.mValue;
 		}
@@ -3843,7 +3851,7 @@ BfType* BfModule::ResolveVarFieldType(BfTypeInstance* typeInstance, BfFieldInsta
 	
 	if (!fieldInstance->mIsInferredType)
 		return fieldType;
-	if (!fieldType->IsVar())
+	if ((!fieldType->IsVar()) && (!fieldType->IsUndefSizedArray()))
 		return fieldType;	
 	
 	SetAndRestoreValue<BfTypeInstance*> prevTypeInstance(mCurTypeInstance, typeInstance);
@@ -3856,7 +3864,7 @@ BfType* BfModule::ResolveVarFieldType(BfTypeInstance* typeInstance, BfFieldInsta
 	if ((!field->mIsStatic) && (typeDef->mIsStatic))
 	{
 		AssertErrorState();		
-		return GetPrimitiveType(BfTypeCode_Var);
+		return fieldType;
 	}
 	
 	bool hadInferenceCycle = false;
@@ -3875,7 +3883,7 @@ BfType* BfModule::ResolveVarFieldType(BfTypeInstance* typeInstance, BfFieldInsta
 				fieldModule->Fail(StrFormat("Field '%s.%s' creates a type inference cycle", TypeToString(fieldOwner).c_str(), fieldDef->mName.c_str()), fieldDef->mTypeRef, true);				
 			}
 						
-			return GetPrimitiveType(BfTypeCode_Var);
+			return fieldType;
 		}
 	}
 	mContext->mFieldResolveReentrys.push_back(fieldInstance);
@@ -3888,7 +3896,7 @@ BfType* BfModule::ResolveVarFieldType(BfTypeInstance* typeInstance, BfFieldInsta
 	{
 		if ((field->mTypeRef->IsA<BfVarTypeReference>()) || (field->mTypeRef->IsA<BfLetTypeReference>()))
 			Fail("Implicitly-typed fields must be initialized", field->GetRefNode());		
-		return GetPrimitiveType(BfTypeCode_Var);
+		return fieldType;
 	}
 
 	BfType* resolvedType = NULL;
@@ -3925,14 +3933,21 @@ BfType* BfModule::ResolveVarFieldType(BfTypeInstance* typeInstance, BfFieldInsta
 			BfTypedValue valueFromExpr;
 			valueFromExpr = GetFieldInitializerValue(fieldInstance);
 			FixIntUnknown(valueFromExpr);
-			resolvedType = valueFromExpr.mType;
+
+			if (fieldType->IsUndefSizedArray())
+			{
+				if ((valueFromExpr.mType != NULL) && (valueFromExpr.mType->IsSizedArray()) && (valueFromExpr.mType->GetUnderlyingType() == fieldType->GetUnderlyingType()))
+					resolvedType = valueFromExpr.mType;
+			}
+			else
+				resolvedType = valueFromExpr.mType;
 		}
 
 		mBfIRBuilder->SetInsertPoint(prevInsertBlock);
 	}
 
 	if (resolvedType == NULL)
-		return GetPrimitiveType(BfTypeCode_Var);
+		return fieldType;
 				
 	fieldInstance->SetResolvedType(resolvedType);
 
@@ -4081,7 +4096,7 @@ BfTypedValue BfModule::GetFieldInitializerValue(BfFieldInstance* fieldInstance,
 	
 	if ((doStore) && (result))
 	{
-		if (fieldInstance->mResolvedType->IsUnknownSizedArray())
+		if (fieldInstance->mResolvedType->IsUndefSizedArray())
 		{
 			AssertErrorState();
 		}

IDEHelper/Compiler/BfModuleTypeUtils.cpp

@@ -5234,7 +5234,7 @@ BfTypeInstance* BfModule::GetWrappedStructType(BfType* type, bool allowSpecializ
 	{
 		if (allowSpecialized)
 		{
-			if (type->IsUnknownSizedArray())
+			if (type->IsUnknownSizedArrayType())
 			{
 				BfUnknownSizedArrayType* sizedArrayType = (BfUnknownSizedArrayType*)type;
 				BfTypeVector typeVector;
@@ -6391,7 +6391,7 @@ BfType* BfModule::ResolveGenericType(BfType* unspecializedType, BfTypeVector* ty
 	if (!unspecializedType->IsUnspecializedType())
 		return unspecializedType;
 
-	if (unspecializedType->IsUnknownSizedArray())
+	if (unspecializedType->IsUnknownSizedArrayType())
 	{
 		auto* arrayType = (BfUnknownSizedArrayType*)unspecializedType;
 		auto elementType = ResolveGenericType(arrayType->mElementType, typeGenericArguments, methodGenericArguments, allowFail);
@@ -12445,7 +12445,7 @@ void BfModule::DoTypeToString(StringImpl& str, BfType* resolvedType, BfTypeNameF
 		DoTypeToString(str, concreteTypeType->mInterface, typeNameFlags, genericMethodNameOverrides);
 		return;
 	}
-	else if (resolvedType->IsUnknownSizedArray())
+	else if (resolvedType->IsUnknownSizedArrayType())
 	{
 		auto arrayType = (BfUnknownSizedArrayType*)resolvedType;
 		DoTypeToString(str, arrayType->mElementType, typeNameFlags, genericMethodNameOverrides);

IDEHelper/Compiler/BfResolvedTypeUtils.cpp

@@ -2785,7 +2785,7 @@ int BfResolvedTypeSet::Hash(BfType* type, LookupContext* ctx, bool allowRef)
 		auto sizedArray = (BfSizedArrayType*)type;
 		int elemHash = Hash(sizedArray->mElementType, ctx) ^ HASH_SIZED_ARRAY;
 		int hashVal = (elemHash << 5) - elemHash;
-		if (type->IsUnknownSizedArray())
+		if (type->IsUnknownSizedArrayType())
 		{
 			auto unknownSizedArray = (BfUnknownSizedArrayType*)type;
 			int elemHash = Hash(unknownSizedArray->mElementCountSource, ctx);
@@ -4060,7 +4060,7 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfTypeReference* rhs, LookupContext*
 			BfTypedValue typedVal = constResolver.Resolve(sizeExpr, NULL, BfConstResolveFlag_ArrayInitSize);
 			if (typedVal.mKind == BfTypedValueKind_GenericConstValue)
 			{
-				if (!lhs->IsUnknownSizedArray())
+				if (!lhs->IsUnknownSizedArrayType())
 					return false;
 
 				auto lhsUnknownSizedArray = (BfUnknownSizedArrayType*)lhs;
@@ -4070,7 +4070,7 @@ bool BfResolvedTypeSet::Equals(BfType* lhs, BfTypeReference* rhs, LookupContext*
 				typedVal = ctx->mModule->Cast(sizeExpr, typedVal, intType);
 			if (typedVal)
 			{				
-				if (lhs->IsUnknownSizedArray())
+				if (lhs->IsUnknownSizedArrayType())
 					return false;				
 				
 				auto constant = ctx->mModule->mBfIRBuilder->GetConstant(typedVal.mValue);

IDEHelper/Compiler/BfResolvedTypeUtils.h

@@ -530,7 +530,7 @@ public:
 	virtual bool IsString() { return false; }
 	virtual bool IsSizedArray() { return false; }
 	virtual bool IsUndefSizedArray() { return false; }
-	virtual bool IsUnknownSizedArray() { return false; }
+	virtual bool IsUnknownSizedArrayType() { return false; }
 	virtual bool IsArray() { return false; }	
 	virtual bool IsDelegate() { return false; }
 	virtual bool IsFunction() { return false; }
@@ -2308,7 +2308,7 @@ public:
 public:
 	virtual bool NeedsExplicitAlignment() override { return mElementType->NeedsExplicitAlignment(); }
 
-	virtual bool IsUnknownSizedArray() override { return true; }
+	virtual bool IsUnknownSizedArrayType() override { return true; }
 
 	virtual bool IsWrappableType() override { return true; }
 	virtual bool IsValueType() override { return true; } // Is a type of struct