TArray<typeNotBeingListed> foo;
// what happens here:
typeNotBeingListed fooTestDirect;
fooTestDirect.

struct felineSimpeStruct
{
	int nMemberOne;
	int nMemberTwo;
	int nMemberThree;
};

void testingArrayHandling()
{
	TArray<felineSimpeStruct> arrayOne;
	// type dot after ] and the correct struct members are listed
	// with listbox content from both VA and default intellisense
	arrayOne[0];
}

#include "Array.h"

struct simpleStruct
{
	int nMemberOne;
	int nMemberTwo;
	int nMemberThree;
};


void testTArrayHandling()
{
	TArray<simpleStruct> arrayDirect;
	TArray<*simpleStruct> arrayPointer;

	// dot stays as dot, and correct members are listed for both
	arrayDirect[0];
	arrayPointer[0];
}

class testFelineBaseClass
{
	virtual void DoingThings();
};

class testFelineDerivedClass : public testFelineBaseClass
{
	virtual void DoingThings();
};

class testFelineDerivedClass2 : public testFelineBaseClass
{
	virtual void DoingThings();
};

void testFelineBaseClass::DoingThings() { };

void testFelineDerivedClass::DoingThings()
{
	testFelineBaseClass::DoingThings();
}

void testFelineDerivedClass2::DoingThings()
{
	testFelineBaseClass::DoingThings();
}

class testFelineBaseClass
{
	virtual void DoingThings();
};

void testFelineBaseClass::DoingThings() { }

class testFelineDerivedClass : public testFelineBaseClass
{
	virtual void DoingThings() override;
};

void testFelineDerivedClass::DoingThings()
{
	// find ref on this function call finds 3 correct references
	testFelineBaseClass::DoingThings();

	// find ref on this function call finds 3 correct references
	// recursive calling
	DoingThings();
}

template <typename T>
class testTemplateBrackets
{
	T operator()(int nArrayMember)
	{
		return null;
	}
};