class simpleFelineTestClass
{
public:
	simpleFelineTestClass(int nSizeOne, int nSizeTwo) { }
	void simpleMethodImplementation();
	void simpleMethodTwo();
	void simpleMethodThree();
	void simpleMethodFour();
};

void simpleForLoopCheck()
{
	std::vector<std::shared_ptr<simpleFelineTestClass> > itemsFoo;
	for (auto & eFoo : itemsFoo)
	{
		// test - type dot after "eFoo"
		eFoo;
	}
}

namespace std {

	//////////////////////////////////////////////////////////////////////////
	// CString iterator support
	//
	// we place it in std to force it to have the same visibility and viability 
	// of any other standard overload of begin/end, and not to hide anything in std,
	// but merely be visible
	//
	// we could put it in its own NS, and then require users to bring that into visibility
	// but that NS could not be inside of Toolbox, or it will still be preferred by any
	// of our Toolbox NS algorithms (e.g. contains)
	//
	// so it has to be equal to std - either by being in std (as I'm doing here) or
	// by putting it in its own NS, and then requiring users to "using CStringIterators" or whatever...
	//

	// CStringT<T>

	template <typename T>
	typename std::enable_if<std::is_same<T, CStringA>::value, const char *>::type
		begin(const T & str) { return str.GetString(); }

	template <typename T>
	typename std::enable_if<std::is_same<T, CStringA>::value, const char *>::type
		end(const T & str) { return str.GetString() + str.GetLength(); }

	template <typename T>
	typename std::enable_if<std::is_same<T, CStringW>::value, const wchar_t *>::type
		begin(const T & str) { return str.GetString(); }

	template <typename T>
	typename std::enable_if<std::is_same<T, CStringW>::value, const wchar_t *>::type
		end(const T & str) { return str.GetString() + str.GetLength(); }

} // std

#include <vector>
#include <memory>

class simpleFelineTestClass
{
public:
	simpleFelineTestClass(int nSizeOne, int nSizeTwo) { }
	void simpleMethodImplementation();
	void simpleMethodTwo();
	void simpleMethodThree();
	void simpleMethodFour();
};

void simpleForLoopCheck()
{
	std::vector<std::shared_ptr<simpleFelineTestClass> > itemsFoo;
	for (auto & eFoo : itemsFoo)
	{
		// test - type dot after "eFoo"
		eFoo;
	}
}

void sanityCheckPointerHandling()
{
	simpleFelineTestClass localVar(1, 3);
	simpleFelineTestClass *pLocalPtr = &localVar;
	// test - here dot is left alone
	localVar;
	// test - here dot is converted to ->
	pLocalPtr;
}

quote:

---

Originally posted by feline

I am really puzzled by the fact that this works in one project, yet fails in another project. File specific and solution specific both make sense, I can easily see how this could happen, but I am not sure what could cause a problem like this to be project specific. Are the two projects both C++? Are the code files in both projects using the same file extensions?

---

quote:

---

Originally posted by feline

When you are testing this code in the different projects in your solution, are you testing in an EMPTY code file?

---

quote:

---

Originally posted by feline

OK, as a sanity check, can you place the caret into "for" and see what is shown in the VA context and definition fields, and also check what alt-g does? I am getting both fields showing nothing, and nothing happens when I press alt-g. I am expecting the same for you.

---

quote:

---

Originally posted by feline

Another sanity check, partly for my own piece of mind, can you try this extended test case please.

---

#include <vector>
#include <memory>

class simpleFelineTestClass
{
public:
	simpleFelineTestClass() { }
	simpleFelineTestClass(int nSizeOne, int nSizeTwo) { }
	void simpleMethodImplementation() { }
	void simpleMethodTwo() { }
	void simpleMethodThree() { }
	void simpleMethodFour() { }
};

void simpleForLoopCheck()
{
	std::vector<std::shared_ptr<simpleFelineTestClass> > itemsFoo;
	for (auto & eFoo : itemsFoo)
	{
		// test - type dot after "eFoo"
		eFoo;
	}
}

void sanityCheckPointerHandling()
{
	simpleFelineTestClass localVar(1, 3);
	simpleFelineTestClass *pLocalPtr = &localVar;
	// test - here dot is left alone
	localVar;
	// test - here dot is converted to ->
	pLocalPtr;

	simpleFelineTestClass testFelineArray[10];
	for (int n = 1; n < 10; ++n)
	{
		auto *felinePtr = &(testFelineArray[n]);
		felinePtr->simpleMethodTwo();
		// TEST THREE - what does typing dot here do?  Is the dot converted to -> or not?
		felinePtr;
	}

	std::vector<simpleFelineTestClass *> itemsSimplePtr;
	for (auto iterPtr : itemsSimplePtr)
	{
		// TEST FOUR - what does typing dot here do?  Is the dot converted to -> or not?
		iterPtr;
	}

	std::shared_ptr<simpleFelineTestClass> simpleSharedPtr;
	auto autoShared = simpleSharedPtr;
	auto & autoRefShared = simpleSharedPtr;
	// TEST FIVE - what does typing dot here do?  Is the dot converted to -> or not?
	autoShared;
	autoRefShared;
}

	template<class _Ty, class _A>
	class vector 
	{
	public:
		typedef _Ty& reference;
		typedef const _Ty& const_reference;
		typedef _Ty* pointer;
		typedef const _Ty* const_pointer;
		typedef std::iterator<_Ty> iterator;
		typedef std::iterator<_Ty> const_iterator;
		typedef std::iterator<_Ty> reverse_iterator;
		typedef std::iterator<_Ty> const_reverse_iterator;

		iterator begin();
		iterator end();
		const_iterator cbegin() const;
		const_iterator cend() const;
		reverse_iterator rbegin();
		reverse_iterator rend();
		const_reverse_iterator rbegin() const;
		const_reverse_iterator rend() const;
	};

	std::vector<simpleFelineTestClass *> itemsSimplePtr;
	for (auto iterPtr : itemsSimplePtr)
	{
		// TEST FOUR - what does typing dot here do?  Is the dot converted to -> or not?
		// FAILS for user, nothing suggested, dot not converted
		iterPtr;
	}

quote:

---

Originally posted by feline
caret in "itemsSimplePtr" where it is declared, the first line of this block, I have:
sanityCheckPointerHandling.itemsSimplePtr
std::vector<simpleFelineTestClass *> itemsSimplePtr

---

quote:

---

Originally posted by feline
caret in "for" keyword, the second line of the block, both fields are blank.

---

quote:

---

Originally posted by feline
caret in "auto" keyword, the second line of the block, I have:
simpleFelineTestClass
class simpleFelineTestClass{...}

---

quote:

---

Originally posted by feline
caret in "iterPtr", the second line of the block, I have:
sanityCheckPointerHandling.iterPtr
simpleFelineTestClass * iterPtr

---

quote:

---

Originally posted by feline
caret in "itemsSimplePtr", the second line of the block, I have:
sanityCheckPointerHandling.itemsSimplePtr
std::vector<simpleFelineTestClass *> itemsSimplePtr

---

quote:

---

Originally posted by feline
caret in "iterPtr" inside the for loop, where we are testing, I have:
sanityCheckPointerHandling.iterPtr
simpleFelineTestClass * iterPtr

---

		// CLASS numeric_limits<long double>
template<> class numeric_limits<long double>
	: public _Num_float_base
	{	// limits for type long double
public:
	typedef long double _Ty;

	std::vector<simpleFelineTestClass *> itemsSimplePtr;
	for (auto iterPtr : itemsSimplePtr)
	{
		// TEST FOUR - what does typing dot here do?  Is the dot converted to -> or not?
		// FAILS for user, nothing suggested, dot not converted
		iterPtr;
	}
	// place caret into "auto" and what is shown in Context and Definition fields?  expecting:
	// std.vector<simpleFelineTestClass *>.iterator 
	// typedef std::iterator<simpleFelineTestClass *> iterator
	auto beginIterator = itemsSimplePtr.begin();
	// type dot after "beginIterator", expecting dot to be converted to ->
	// and listbox showing members of class "simpleFelineTestClass"
	beginIterator;