Method CompileReified

IDEHelper/Compiler/BfCompiler.cpp:6934–7017

}

void BfCompiler::CompileReified()
{
	BfLogSysM("BfCompiler::CompileReified\n");
	BP_ZONE("Compile_ResolveTypeDefs");

	Array<BfTypeDef*> deferTypeDefs;

	for (auto typeDef : mSystem->mTypeDefs)
	{
		mSystem->CheckLockYield();
		if (mCanceling)
		{
			BfLogSysM("Canceling from Compile typeDef loop\n");
			break;
		}

		if (typeDef->mProject->mDisabled)
			continue;

		if (typeDef->mIsPartial)
			continue;

		auto scratchModule = mContext->mScratchModule;
		bool isAlwaysInclude = (typeDef->mIsAlwaysInclude) || (typeDef->mProject->mAlwaysIncludeAll);

		auto typeOptions = scratchModule->GetTypeOptions(typeDef);
		if (typeOptions != NULL)
			isAlwaysInclude = typeOptions->Apply(isAlwaysInclude, BfOptionFlags_ReflectAlwaysIncludeType);

		if (typeDef->mProject->IsTestProject())
		{
			for (auto methodDef : typeDef->mMethods)
			{
				auto methodDeclaration = methodDef->GetMethodDeclaration();
				if ((methodDeclaration != NULL) && (methodDeclaration->mAttributes != NULL) &&
					(methodDeclaration->mAttributes->Contains("Test")))
					isAlwaysInclude = true;
			}
		}

		//TODO: Just because the type is required doesn't mean we want to reify it. Why did we have that check?
		if ((mOptions.mCompileOnDemandKind != BfCompileOnDemandKind_AlwaysInclude) && (!isAlwaysInclude))
		{
			if (typeDef->mGenericParamDefs.IsEmpty())
				deferTypeDefs.Add(typeDef);
			continue;
		}

		scratchModule->ResolveTypeDef(typeDef, BfPopulateType_Full);
	}

	// Resolve remaining typedefs as unreified so we can check their attributes
	for (auto typeDef : deferTypeDefs)
	{
		auto type = mContext->mUnreifiedModule->ResolveTypeDef(typeDef, BfPopulateType_Identity);
		if (type == NULL)
			continue;
		auto typeInst = type->ToTypeInstance();