Bug 446711 - Name resolution problem with dependent enumeration

core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/core/parser/tests/ast2/AST2CPPTests.java

@@ -139,6 +139,7 @@ import org.eclipse.cdt.core.parser.ParserLanguage;
 import org.eclipse.cdt.core.parser.util.CharArrayUtils;
 import org.eclipse.cdt.internal.core.dom.parser.SizeofCalculator;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTNameBase;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPBasicType;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPClassType;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPMethod;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ClassTypeHelper;
@@ -7233,6 +7234,134 @@ public class AST2CPPTests extends AST2TestBase {
 		ba.assertNonProblem("f(!p)", 1);
 	}
 
+	//	template<typename T>
+	//	struct A {
+	//	  enum {
+	//	    e1 = 0,
+	//	    e2 = int(e1)
+	//	  };
+	//	};
+	//
+	//	template<typename T, int v = A<T>::e2>
+	//	struct B;
+	//
+	//	template<typename T>
+	//	struct B<T, 0> {
+	//	  void waldo();
+	//	};
+	//
+	//	void test(B<int>& p) {
+	//	  p.waldo();
+	//	}
+	public void testDependentEnumeration_446711a() throws Exception {
+		parseAndCheckBindings();
+	}
+
+	//	constexpr int f(int p) { return p; }
+	//	constexpr long f(long p) { return p + 0x100000000L; }
+	//
+	//	template<typename T>
+	//	struct A {
+	//	  enum {
+	//	    e1 = 0,
+	//	    e2 = f(e1)
+	//	  };
+	//	};
+	//
+	//	template<typename T, long v = A<T>::e2>
+	//	struct B;
+	//
+	//	template<typename T>
+	//	struct B<T, 0> {
+	//	  void waldo();
+	//	};
+	//
+	//	void test(B<int>& p) {
+	//	  p.waldo();
+	//	}
+	public void testDependentEnumeration_446711b() throws Exception {
+		parseAndCheckBindings();
+	}
+
+	//	constexpr int f(long p) { return p; }
+	//	constexpr long f(int p) { return p + 0x100000000L; }
+	//
+	//	template<typename T>
+	//	struct A {
+	//	  enum {
+	//	    e1 = 0L,
+	//	    e2 = f(e1)
+	//	  };
+	//	};
+	//
+	//	template<typename T, long v = A<T>::e2>
+	//	struct B;
+	//
+	//	template<typename T>
+	//	struct B<T, 0> {
+	//	  void waldo();
+	//	};
+	//
+	//	void test(B<int>& p) {
+	//	  p.waldo();
+	//	}
+	public void testDependentEnumeration_446711c() throws Exception {
+		parseAndCheckBindings();
+	}
+
+	//	constexpr int f(int p) { return p; }
+	//	constexpr long f(long p) { return p + 0x100000000L; }
+	//
+	//	template<typename T, T v>
+	//	struct A {
+	//	  enum {
+	//	    e1 = v,
+	//	    e2 = f(e1)
+	//	  };
+	//	};
+	//
+	//	template<typename T, T u, long v = A<T, u>::e2>
+	//	struct B;
+	//
+	//	template<typename T, T u>
+	//	struct B<T, u, 0> {
+	//	  void waldo();
+	//	};
+	//
+	//	void test(B<int, 0>& p) {
+	//	  p.waldo();
+	//	}
+	public void _testDependentEnumeration_446711d() throws Exception {
+		parseAndCheckBindings();
+	}
+
+	//	constexpr int f(int p) { return p; }
+	//	constexpr long f(long p) { return p + 0x100000000L; }
+	//
+	//	template<typename T, T v>
+	//	struct A {
+	//	  enum {
+	//	    e1 = v,
+	//	    e2 = f(e1)
+	//	  };
+	//	};
+	//
+	//	template<typename T, T u, long v = A<T, u>::e2>
+	//	struct B;
+	//
+	//	template<typename T, T u>
+	//	struct B<T, u, 0> {
+	//	  void waldo();
+	//	};
+	//
+	//	void test(B<long, 0>& p) {
+	//	  p.waldo();
+	//	}
+	public void _testDependentEnumeration_446711e() throws Exception {
+		BindingAssertionHelper helper = getAssertionHelper();
+		helper.assertProblemOnFirstIdentifier(".waldo()");
+	}
+
 	//	class S {
 	//	  S(int);
 	//	};
@@ -8862,7 +8991,7 @@ public class AST2CPPTests extends AST2TestBase {
 		bh.assertProblem("xl;", -1);
 	}
 
-	//	void f(int);
+	//	constexpr int f(int);
 	//	enum class X {e1, e2= e1+2, e3};
 	//	enum class Y {e1, e2= f(e1)+2, e3};
 	//	enum A {e1, e2= e1+2, e3};
@@ -10634,15 +10763,15 @@ public class AST2CPPTests extends AST2TestBase {
 	public void testUnderlyingTypeBuiltin_411196() throws Exception {
 		BindingAssertionHelper helper = getAssertionHelper();
 
-		assertSameType((ITypedef) helper.assertNonProblem("short1_type"), CPPVisitor.SHORT_TYPE);
+		assertSameType((ITypedef) helper.assertNonProblem("short1_type"), CPPBasicType.SHORT);
-		assertSameType((ITypedef) helper.assertNonProblem("short2_type"), CPPVisitor.SHORT_TYPE);
+		assertSameType((ITypedef) helper.assertNonProblem("short2_type"), CPPBasicType.SHORT);
 
-		assertSameType((ITypedef) helper.assertNonProblem("scoped_type"), CPPVisitor.INT_TYPE);
+		assertSameType((ITypedef) helper.assertNonProblem("scoped_type"), CPPBasicType.INT);
 
-		assertSameType((ITypedef) helper.assertNonProblem("unsigned_type"), CPPVisitor.UNSIGNED_INT);
+		assertSameType((ITypedef) helper.assertNonProblem("unsigned_type"), CPPBasicType.UNSIGNED_INT);
-		assertSameType((ITypedef) helper.assertNonProblem("int_type"), CPPVisitor.INT_TYPE);
+		assertSameType((ITypedef) helper.assertNonProblem("int_type"), CPPBasicType.INT);
-		assertSameType((ITypedef) helper.assertNonProblem("ulong_type"), CPPVisitor.UNSIGNED_LONG);
+		assertSameType((ITypedef) helper.assertNonProblem("ulong_type"), CPPBasicType.UNSIGNED_LONG);
-		assertSameType((ITypedef) helper.assertNonProblem("loong_type"), CPPVisitor.LONG_TYPE);
+		assertSameType((ITypedef) helper.assertNonProblem("loong_type"), CPPBasicType.LONG);
 	}
 
 	// namespace A {

core/org.eclipse.cdt.core.tests/parser/org/eclipse/cdt/internal/index/tests/IndexGPPBindingResolutionTest.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2013 Nathan Ridge.
+ * Copyright (c) 2013, 2014 Nathan Ridge.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -10,12 +10,12 @@
  *******************************************************************************/
 package org.eclipse.cdt.internal.index.tests;
 
+import junit.framework.TestSuite;
+
 import org.eclipse.cdt.core.dom.ast.ITypedef;
 import org.eclipse.cdt.core.dom.ast.gnu.cpp.GPPLanguage;
 import org.eclipse.cdt.core.testplugin.TestScannerProvider;
-import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPBasicType;
-
-import junit.framework.TestSuite;
 
 /**
  * For testing resolution of bindings in C++ code with GNU extensions.
@@ -107,14 +107,14 @@ public abstract class IndexGPPBindingResolutionTest extends IndexBindingResoluti
 	//	typedef underlying_type<e_ulong>::type ulong_type;
 	//	typedef underlying_type<e_long>::type loong_type;
 	public void testUnderlyingTypeBuiltin_bug411196() throws Exception {
-		assertSameType((ITypedef) getBindingFromASTName("short1_type", 0), CPPVisitor.SHORT_TYPE);
+		assertSameType((ITypedef) getBindingFromASTName("short1_type", 0), CPPBasicType.SHORT);
-		assertSameType((ITypedef) getBindingFromASTName("short2_type", 0), CPPVisitor.SHORT_TYPE);
+		assertSameType((ITypedef) getBindingFromASTName("short2_type", 0), CPPBasicType.SHORT);
 
-		assertSameType((ITypedef) getBindingFromASTName("scoped_type", 0), CPPVisitor.INT_TYPE);
+		assertSameType((ITypedef) getBindingFromASTName("scoped_type", 0), CPPBasicType.INT);
 		
-		assertSameType((ITypedef) getBindingFromASTName("unsigned_type", 0), CPPVisitor.UNSIGNED_INT);
+		assertSameType((ITypedef) getBindingFromASTName("unsigned_type", 0), CPPBasicType.UNSIGNED_INT);
-		assertSameType((ITypedef) getBindingFromASTName("int_type", 0), CPPVisitor.INT_TYPE);
+		assertSameType((ITypedef) getBindingFromASTName("int_type", 0), CPPBasicType.INT);
-		assertSameType((ITypedef) getBindingFromASTName("ulong_type", 0), CPPVisitor.UNSIGNED_LONG);
+		assertSameType((ITypedef) getBindingFromASTName("ulong_type", 0), CPPBasicType.UNSIGNED_LONG);
-		assertSameType((ITypedef) getBindingFromASTName("loong_type", 0), CPPVisitor.LONG_TYPE);
+		assertSameType((ITypedef) getBindingFromASTName("loong_type", 0), CPPBasicType.LONG);
 	}
 }

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/ASTEnumerator.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2008, 2013 Wind River Systems, Inc. and others.
+ * Copyright (c) 2008, 2014 Wind River Systems, Inc. and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -12,12 +12,20 @@
 package org.eclipse.cdt.internal.core.dom.parser;
 
 import org.eclipse.cdt.core.dom.ast.ASTVisitor;
-import org.eclipse.cdt.core.dom.ast.IASTEnumerationSpecifier;
 import org.eclipse.cdt.core.dom.ast.IASTEnumerationSpecifier.IASTEnumerator;
 import org.eclipse.cdt.core.dom.ast.IASTExpression;
 import org.eclipse.cdt.core.dom.ast.IASTName;
 import org.eclipse.cdt.core.dom.ast.IASTNode;
+import org.eclipse.cdt.core.dom.ast.IBasicType;
+import org.eclipse.cdt.core.dom.ast.IBasicType.Kind;
+import org.eclipse.cdt.core.dom.ast.IBinding;
+import org.eclipse.cdt.core.dom.ast.IType;
 import org.eclipse.cdt.core.dom.ast.IValue;
+import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTEnumerationSpecifier;
+import org.eclipse.cdt.core.dom.ast.cpp.ICPPEnumeration;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPBasicType;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPEnumerator;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.SemanticUtil;
 
 /**
  * Base class for C and C++ enumerators.
@@ -113,9 +121,9 @@ public abstract class ASTEnumerator extends ASTNode implements IASTEnumerator, I
 		if (integralValue == null) {
 			IASTNode parent= getParent();
 			if (parent instanceof IASTInternalEnumerationSpecifier) {
-				IASTInternalEnumerationSpecifier ies= (IASTInternalEnumerationSpecifier) parent;
+				IASTInternalEnumerationSpecifier enumeration= (IASTInternalEnumerationSpecifier) parent;
-				if (ies.startValueComputation()) { // Prevent infinite recursion.
+				if (enumeration.startValueComputation()) { // Prevent infinite recursion.
-					createEnumValues((IASTEnumerationSpecifier) parent);
+					computeEnumValues(enumeration);
 				}
 			}		
 			if (integralValue == null) {
@@ -125,28 +133,104 @@ public abstract class ASTEnumerator extends ASTNode implements IASTEnumerator, I
 		return integralValue;
 	}
 
-	private void createEnumValues(IASTEnumerationSpecifier parent) {
+	private static void computeEnumValues(IASTInternalEnumerationSpecifier enumeration) {
-		IValue previousExplicitValue = null;
+		try {
-		int delta = 0;
+			IType fixedType = null;
-		IASTEnumerator[] etors= parent.getEnumerators();
+			if (enumeration instanceof ICPPASTEnumerationSpecifier) {
-		for (IASTEnumerator etor : etors) {
+				IBinding binding = enumeration.getName().resolveBinding();
-			IValue val;
+				if (binding instanceof ICPPEnumeration) {
-			IASTExpression expr= etor.getValue();
+					fixedType = ((ICPPEnumeration) binding).getFixedType();
-			if (expr != null) {
-				val= Value.create(expr, Value.MAX_RECURSION_DEPTH);
-				previousExplicitValue = val;
-				delta = 1;
-			} else {
-				if (previousExplicitValue != null) {
-					val = Value.incrementedValue(previousExplicitValue, delta);
-				} else {
-					val = Value.create(delta);
 				}
-				delta++;
 			}
-			if (etor instanceof ASTEnumerator) {
+			IType type = fixedType == null ? CPPBasicType.INT : null;
-				((ASTEnumerator) etor).integralValue= val;
+			IValue previousExplicitValue = null;
+			int delta = 0;
+			IASTEnumerator[] etors= enumeration.getEnumerators();
+			for (IASTEnumerator etor : etors) {
+				IBinding etorBinding = etor.getName().resolveBinding();
+				IValue val;
+				IASTExpression expr= etor.getValue();
+				if (expr != null) {
+					val= Value.create(expr, Value.MAX_RECURSION_DEPTH);
+					previousExplicitValue = val;
+					delta = 1;
+					if (fixedType == null) {
+						type = expr.getExpressionType();
+						type = SemanticUtil.getNestedType(type, SemanticUtil.CVTYPE | SemanticUtil.TDEF);
+						if (etorBinding instanceof CPPEnumerator) {
+							((CPPEnumerator) etorBinding).setInternalType(type);
+						}
+					}
+				} else {
+					if (previousExplicitValue != null) {
+						val = Value.incrementedValue(previousExplicitValue, delta);
+					} else {
+						val = Value.create(delta);
+					}
+					delta++;
+					if (fixedType == null && type instanceof IBasicType) {
+						type = getTypeOfIncrementedValue((IBasicType) type, val);
+						if (etorBinding instanceof CPPEnumerator) {
+							((CPPEnumerator) etorBinding).setInternalType(type);
+						}
+					}
+				}
+				if (etor instanceof ASTEnumerator) {
+					((ASTEnumerator) etor).integralValue= val;
+				}
 			}
+		} finally {
+			enumeration.finishValueComputation();
 		}
 	}
+
+	/**
+	 * [dcl.enum] 7.2-5:
+	 * "... the type of the initializing value is the same as the type of the initializing value of
+	 * the preceding enumerator unless the incremented value is not representable in that type, in
+	 * which case the type is an unspecified integral type sufficient to contain the incremented
+	 * value. If no such type exists, the program is ill-formed."
+	 *
+	 * @param type the type of the previous value
+	 * @param val the incremented value
+	 * @return the type of the incremented value
+	 */
+	public static IBasicType getTypeOfIncrementedValue(IBasicType type, IValue val) {
+		Long numericalValue = val.numericalValue();
+		if (numericalValue != null) {
+			long longValue = numericalValue.longValue();
+			if ((type.getKind() != Kind.eInt && type.getKind() != Kind.eInt128) ||
+					type.isShort()) {
+				type = type.isUnsigned() ? CPPBasicType.UNSIGNED_INT : CPPBasicType.INT;
+			}
+			if (!ArithmeticConversion.fitsIntoType(type, longValue)) {
+				if (!type.isUnsigned()) {
+					if (type.getKind() != Kind.eInt128) {
+						if (type.isLongLong()) {
+							type = CPPBasicType.UNSIGNED_INT128;
+						} else if (type.isLong()) {
+							type = CPPBasicType.UNSIGNED_LONG_LONG;
+						} else {
+							type = CPPBasicType.UNSIGNED_LONG;
+						}
+					}
+				} else {
+					if (type.getKind() == Kind.eInt128) {
+						if (longValue >= 0) {
+							type = CPPBasicType.UNSIGNED_INT128;
+						}
+					} else {
+						if (type.isLongLong()) {
+							type = CPPBasicType.INT128;
+						} else if (type.isLong()) {
+							type = CPPBasicType.LONG_LONG;
+						} else {
+							type = CPPBasicType.LONG;
+						}
+					}
+				}
+			}
+		}
+		return type;
+	}
 }

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/ArithmeticConversion.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2009, 2012 Wind River Systems, Inc. and others.
+ * Copyright (c) 2009, 2014 Wind River Systems, Inc. and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -19,7 +19,6 @@ import org.eclipse.cdt.core.dom.ast.IBasicType;
 import org.eclipse.cdt.core.dom.ast.IBasicType.Kind;
 import org.eclipse.cdt.core.dom.ast.IEnumeration;
 import org.eclipse.cdt.core.dom.ast.IType;
-import org.eclipse.cdt.core.dom.ast.cpp.ICPPBasicType;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPEnumeration;
 import org.eclipse.cdt.internal.core.dom.parser.SizeofCalculator.SizeAndAlignment;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.SemanticUtil;
@@ -196,7 +195,7 @@ public abstract class ArithmeticConversion {
 			return unsignedType;
 		}
 		
-		// the signed has the higher rank
+		// The signed has the higher rank.
 		if (signedRank.ordinal() > unsignedRank.ordinal()) {
 			return signedType;
 		}
@@ -227,7 +226,7 @@ public abstract class ArithmeticConversion {
 				return createBasicType(Kind.eInt, domain.getModifier());
 
 			case eChar32:
-				// Assuming 32 bits
+				// Assuming 32 bits.
 				return createBasicType(Kind.eInt, domain.getModifier() | IBasicType.IS_UNSIGNED);
 
 			case eInt:
@@ -332,7 +331,7 @@ public abstract class ArithmeticConversion {
 		}
 	}
 
-	public static boolean fitsIntoType(ICPPBasicType basicTarget, long n) {
+	public static boolean fitsIntoType(IBasicType basicTarget, long n) {
 		final Kind kind = basicTarget.getKind();
 		switch (kind) {
 		case eInt:
@@ -372,9 +371,9 @@ public abstract class ArithmeticConversion {
 	}
 
 	/**
-	 * Make a best-effort guess at the sizeof() of an integral type.  
+	 * Makes a best-effort guess at the sizeof() of an integral type.  
 	 */
-	private static long getApproximateSize(ICPPBasicType type) {
+	private static long getApproximateSize(IBasicType type) {
 		switch (type.getKind()) {
 			case eChar: return 1;
 			case eWChar: return 2;
@@ -396,12 +395,13 @@ public abstract class ArithmeticConversion {
 
 	/**
 	 * Checks whether a target integral type can represent all values of a source integral type.
+	 *
 	 * @param target the target integral type
 	 * @param source the source integral type
 	 * @param point point for sizeof lookup
 	 * @return whether the target integral type can represent all values of the source integral type
 	 */
-	public static boolean fitsIntoType(ICPPBasicType target, ICPPBasicType source, IASTNode point) {
+	public static boolean fitsIntoType(IBasicType target, IBasicType source, IASTNode point) {
 		// A boolean cannot represent any other type.
 		if (target.getKind() == Kind.eBoolean && source.getKind() != Kind.eBoolean)
 			return false;

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/IASTInternalEnumerationSpecifier.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2008, 2011 Wind River Systems, Inc. and others.
+ * Copyright (c) 2008, 2014 Wind River Systems, Inc. and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -7,6 +7,7 @@
  *
  * Contributors:
  *     Markus Schorn - initial API and implementation
+ *     Sergey Prigogin (Google)
  *******************************************************************************/ 
 package org.eclipse.cdt.internal.core.dom.parser;
 
@@ -17,10 +18,20 @@ import org.eclipse.cdt.core.dom.ast.IASTEnumerationSpecifier;
  */
 public interface IASTInternalEnumerationSpecifier extends IASTEnumerationSpecifier {
 	/**
-	 * Notifies that the value computation for the enumeration has started. Returns whether this is
+	 * Notifies that the value computation for the enumeration has started.
-	 * the first attempt to do so.
+	 * Returns {@code true} if this is the first attempt to do so.
 	 */
 	boolean startValueComputation();
+
+	/**
+	 * Notifies that the value computation for the enumeration has finished.
+	 */
+	void finishValueComputation();
+
+	/**
+	 * Returns {@code true} if the value computation has started but hasn't finished yet.
+	 */
+	boolean isValueComputationInProgress();
 	
 	/**
 	 * @since 5.1

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/SizeofCalculator.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2011, 2013 Google, Inc and others.
+ * Copyright (c) 2011, 2014 Google, Inc and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -30,12 +30,12 @@ import org.eclipse.cdt.core.dom.ast.IType;
 import org.eclipse.cdt.core.dom.ast.IValue;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPBase;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPClassType;
-import org.eclipse.cdt.core.dom.ast.cpp.ICPPEnumeration;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPMethod;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPPointerToMemberType;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPReferenceType;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ClassTypeHelper;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.SemanticUtil;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.TypeTraits;
 
 /**
  * Calculator of in-memory size and alignment of types.
@@ -85,7 +85,7 @@ public class SizeofCalculator {
 	 * @param type the type to get size and alignment for.
 	 * @param point a node belonging to the AST of the translation unit defining context for
 	 *     the size calculation.
-	 * @return size and alignment, or <code>null</code> if could not be calculated.
+	 * @return size and alignment, or {@code null} if could not be calculated.
 	 */
 	public static SizeAndAlignment getSizeAndAlignment(IType type, IASTNode point) {
 		SizeofCalculator calc = point == null ?
@@ -173,7 +173,7 @@ public class SizeofCalculator {
 	/**
 	 * Calculates size and alignment for the given type.
 	 * @param type the type to get size and alignment for.
-	 * @return size and alignment, or <code>null</code> if could not be calculated.
+	 * @return size and alignment, or {@code null} if could not be calculated.
 	 */
 	public SizeAndAlignment sizeAndAlignment(IType type) {
 		type = SemanticUtil.getNestedType(type, SemanticUtil.CVTYPE | SemanticUtil.TDEF);
@@ -183,8 +183,8 @@ public class SizeofCalculator {
 		if (type instanceof IBasicType) {
 			return sizeAndAlignment((IBasicType) type);
 		}
-		// [expr.sizeof]/2: "When applied to a reference or a reference type, the
+		// [expr.sizeof]/2: "When applied to a reference or a reference type,
-		// result is the size of the referenced type."
+		// the result is the size of the referenced type."
 		if (type instanceof ICPPReferenceType) {
 			return sizeAndAlignment(((ICPPReferenceType) type).getType());
 		}
@@ -207,7 +207,7 @@ public class SizeofCalculator {
 
 	/**
 	 * Returns size and alignment of pointer types.
-	 * @return size and alignment of pointer types, or <code>null</code> if unknown.
+	 * @return size and alignment of pointer types, or {@code null} if unknown.
 	 */
 	public SizeAndAlignment sizeAndAlignmentOfPointer() {
 		return sizeof_pointer;
@@ -247,24 +247,11 @@ public class SizeofCalculator {
 	}
 
 	private SizeAndAlignment sizeAndAlignment(IEnumeration type) {
-		if (type instanceof ICPPEnumeration) {
+		IType underlyingType = TypeTraits.underlyingType(type);
-			IType fixedType = ((ICPPEnumeration) type).getFixedType();
+		if (underlyingType instanceof IBasicType) {
-			if (fixedType != null) {
+			return sizeAndAlignment((IBasicType) underlyingType);
-				return sizeAndAlignment(fixedType);
-			}
 		}
-		long range = Math.max(Math.abs(type.getMinValue()) - 1, Math.abs(type.getMaxValue()));
+		return null;
-		if (range >= (2 << 32))
-			return size_8;
-		if (type.getMinValue() < 0)
-			range *= 2;
-		if (range >= (2 << 32))
-			return size_8;
-		if (range >= (2 << 16))
-			return size_4;
-		if (range >= (2 << 8))
-			return size_2;
-		return SIZE_1;
 	}
 
 	private SizeAndAlignment sizeAndAlignment(IArrayType type) {

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/c/CASTEnumerationSpecifier.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2005, 2011 IBM Corporation and others.
+ * Copyright (c) 2005, 2014 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -9,6 +9,7 @@
  *     John Camelon (IBM Rational Software) - Initial API and implementation
  *     Markus Schorn (Wind River Systems)
  *     Yuan Zhang / Beth Tibbitts (IBM Research)
+ *     Sergey Prigogin (Google)
  *******************************************************************************/
 package org.eclipse.cdt.internal.core.dom.parser.c;
 
@@ -23,9 +24,11 @@ import org.eclipse.cdt.internal.core.dom.parser.IASTInternalEnumerationSpecifier
  */
 public class CASTEnumerationSpecifier extends CASTBaseDeclSpecifier 
 		implements IASTInternalEnumerationSpecifier, ICASTEnumerationSpecifier {
-    private IASTName name;
+    private IASTName fName;
-	private boolean valuesComputed;
+	private Boolean fValuesComputed;
-    
+    private IASTEnumerator[] fEnumerators = IASTEnumerator.EMPTY_ENUMERATOR_ARRAY;
+    private int fNumEnumerators;
+
     public CASTEnumerationSpecifier() {
 	}
 
@@ -45,7 +48,7 @@ public class CASTEnumerationSpecifier extends CASTBaseDeclSpecifier
 	}
 
 	protected <T extends CASTEnumerationSpecifier> T copy(T copy, CopyStyle style) {
-		copy.setName(name == null ? null : name.copy(style));
+		copy.setName(fName == null ? null : fName.copy(style));
 		for (IASTEnumerator enumerator : getEnumerators()) {
 			copy.addEnumerator(enumerator == null ? null : enumerator.copy(style));
 		}
@@ -54,38 +57,43 @@ public class CASTEnumerationSpecifier extends CASTBaseDeclSpecifier
 	
 	@Override
 	public boolean startValueComputation() {
-		if (valuesComputed)
+		if (fValuesComputed != null)
 			return false;
 		
-		valuesComputed= true;
+		fValuesComputed= Boolean.FALSE;
 		return true;
 	}
 
+	@Override
+	public void finishValueComputation() {
+		fValuesComputed= Boolean.TRUE;
+	}
+
+	@Override
+	public boolean isValueComputationInProgress() {
+		return fValuesComputed != null && !fValuesComputed;
+	}
+
 	@Override
 	public void addEnumerator(IASTEnumerator enumerator) {
         assertNotFrozen();
     	if (enumerator != null) {
     		enumerator.setParent(this);
 			enumerator.setPropertyInParent(ENUMERATOR);
-    		enumerators = ArrayUtil.appendAt(IASTEnumerator.class, enumerators, ++enumeratorsPos, enumerator);
+    		fEnumerators = ArrayUtil.appendAt(fEnumerators, fNumEnumerators++, enumerator);
     	}
     }
 
     @Override
 	public IASTEnumerator[] getEnumerators() {        
-        if (enumerators == null) return IASTEnumerator.EMPTY_ENUMERATOR_ARRAY;
+        fEnumerators = ArrayUtil.trim(fEnumerators, fNumEnumerators);
-        enumerators = ArrayUtil.trimAt(IASTEnumerator.class, enumerators, enumeratorsPos);
+        return fEnumerators;
-        return enumerators;
     }
 
-    private IASTEnumerator [] enumerators = null;
-    private int enumeratorsPos = -1;
-
- 
     @Override
 	public void setName(IASTName name) {
         assertNotFrozen();
-        this.name = name;
+        this.fName = name;
         if (name != null) {
 			name.setParent(this);
 			name.setPropertyInParent(ENUMERATION_NAME);
@@ -94,7 +102,7 @@ public class CASTEnumerationSpecifier extends CASTBaseDeclSpecifier
 
     @Override
 	public IASTName getName() {
-        return name;
+        return fName;
     }
 
     @Override
@@ -106,7 +114,7 @@ public class CASTEnumerationSpecifier extends CASTBaseDeclSpecifier
 	            default: break;
 	        }
 		}
-        if (name != null && !name.accept(action))
+        if (fName != null && !fName.accept(action))
         	return false;
         IASTEnumerator[] etors = getEnumerators();
         for (int i = 0; i < etors.length; i++) {
@@ -125,7 +133,7 @@ public class CASTEnumerationSpecifier extends CASTBaseDeclSpecifier
 
 	@Override
 	public int getRoleForName(IASTName n) {
-		if (this.name == n)
+		if (this.fName == n)
 			return r_definition;
 		return r_unclear;
 	}

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPASTEnumerationSpecifier.java

@@ -9,6 +9,7 @@
  *     John Camelon (IBM) - Initial API and implementation
  *     Markus Schorn (Wind River Systems)
  *     Thomas Corbat (IFS)
+ *     Sergey Prigogin (Google)
  *******************************************************************************/
 package org.eclipse.cdt.internal.core.dom.parser.cpp;
 
@@ -21,7 +22,7 @@ import org.eclipse.cdt.core.parser.util.ArrayUtil;
 import org.eclipse.cdt.internal.core.dom.parser.IASTInternalEnumerationSpecifier;
 
 /**
- * AST node for c++ enumeration specifiers.
+ * AST node for C++ enumeration specifiers.
  */
 public class CPPASTEnumerationSpecifier extends CPPASTBaseDeclSpecifier
 		implements IASTInternalEnumerationSpecifier, ICPPASTEnumerationSpecifier {
@@ -30,10 +31,10 @@ public class CPPASTEnumerationSpecifier extends CPPASTBaseDeclSpecifier
 	private IASTName fName;
 	private ICPPASTDeclSpecifier fBaseType;
 
-	private IASTEnumerator[] fItems;
+	private IASTEnumerator[] fEnumerators = IASTEnumerator.EMPTY_ENUMERATOR_ARRAY;
-	private int fItemPos= -1;
+	private int fNumEnumerators;
 
-	private boolean fValuesComputed;
+	private Boolean fValuesComputed;
 	private CPPEnumScope fScope;
 
 	public CPPASTEnumerationSpecifier() {
@@ -64,30 +65,37 @@ public class CPPASTEnumerationSpecifier extends CPPASTBaseDeclSpecifier
 	
 	@Override
 	public boolean startValueComputation() {
-		if (fValuesComputed)
+		if (fValuesComputed != null)
 			return false;
 		
-		fValuesComputed= true;
+		fValuesComputed= Boolean.FALSE;
 		return true;
 	}
 
+	@Override
+	public void finishValueComputation() {
+		fValuesComputed= Boolean.TRUE;
+	}
+
+	@Override
+	public boolean isValueComputationInProgress() {
+		return fValuesComputed != null && !fValuesComputed;
+	}
+
 	@Override
 	public void addEnumerator(IASTEnumerator enumerator) {
         assertNotFrozen();
 		if (enumerator != null) {
 			enumerator.setParent(this);
 			enumerator.setPropertyInParent(ENUMERATOR);
-			fItems = ArrayUtil.appendAt( IASTEnumerator.class, fItems, ++fItemPos, enumerator );
+			fEnumerators = ArrayUtil.appendAt(fEnumerators, fNumEnumerators++, enumerator);
 		}
 	}
 
 	@Override
 	public IASTEnumerator[] getEnumerators() {
-		if (fItems == null)
+		fEnumerators = ArrayUtil.trim(fEnumerators, fNumEnumerators);
-			return IASTEnumerator.EMPTY_ENUMERATOR_ARRAY;
+		return fEnumerators;
-		
-		fItems = ArrayUtil.trimAt(IASTEnumerator.class, fItems, fItemPos);
-		return fItems;
 	}
 
 	@Override

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPBasicType.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2004, 2012 IBM Corporation and others.
+ * Copyright (c) 2004, 2014 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -31,11 +31,22 @@ import org.eclipse.core.runtime.CoreException;
  * Built-in c++ type.
  */
 public class CPPBasicType implements ICPPBasicType, ISerializableType {
-	private static final int FROM_STRING_LITERAL = 1 << 31;
 	public static final CPPBasicType BOOLEAN = new CPPBasicType(Kind.eBoolean, 0, null);
 	public static final CPPBasicType NULL_PTR = new CPPBasicType(Kind.eNullPtr, 0, null);
     public static final CPPBasicType UNSPECIFIED_TYPE = new CPPBasicType(Kind.eUnspecified, 0);
-	
+	public static final CPPBasicType SHORT = new CPPBasicType(Kind.eInt, IBasicType.IS_SHORT);
+	public static final CPPBasicType INT = new CPPBasicType(Kind.eInt, 0);
+	public static final CPPBasicType LONG = new CPPBasicType(Kind.eInt, IBasicType.IS_LONG);
+	public static final CPPBasicType LONG_LONG = new CPPBasicType(Kind.eInt, IBasicType.IS_LONG_LONG);
+	public static final CPPBasicType INT128 = new CPPBasicType(Kind.eInt128, 0);
+	public static final CPPBasicType UNSIGNED_SHORT = new CPPBasicType(Kind.eInt, IBasicType.IS_SHORT | IBasicType.IS_UNSIGNED);
+	public static final CPPBasicType UNSIGNED_INT = new CPPBasicType(Kind.eInt, IBasicType.IS_UNSIGNED);
+	public static final CPPBasicType UNSIGNED_LONG = new CPPBasicType(Kind.eInt, IBasicType.IS_LONG | IBasicType.IS_UNSIGNED);
+	public static final CPPBasicType UNSIGNED_LONG_LONG = new CPPBasicType(Kind.eInt, IBasicType.IS_LONG_LONG | IBasicType.IS_UNSIGNED);
+	public static final CPPBasicType UNSIGNED_INT128 = new CPPBasicType(Kind.eInt128, IBasicType.IS_UNSIGNED);
+
+	private static final int FROM_STRING_LITERAL = 1 << 31;
+
 	private final Kind fKind;
 	private final int fModifiers;
 	private Long fAssociatedValue;

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPEnumerationSpecialization.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2013 Nathan Ridge and others.
+ * Copyright (c) 2013, 2014 Nathan Ridge and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -8,6 +8,7 @@
  * Contributors:
  *     Nathan Ridge - Initial API and implementation
  *     Marc-Andre Laperle (Ericsson)
+ *     Sergey Prigogin (Google)
  *******************************************************************************/
 package org.eclipse.cdt.internal.core.dom.parser.cpp;
 
@@ -99,13 +100,12 @@ public class CPPEnumerationSpecialization extends CPPSpecialization implements I
 			return enumerator;
 		}
 
-		// The specialized enumerators are already computed, just need
+		// The specialized enumerators are already computed, just need to look up the right one.
-		// to look up the right one.
 		IEnumerator[] unspecializedEnumerators = getSpecializedBinding().getEnumerators();
 		for (int i = 0; i < fEnumerators.length; ++i) {
 			if (enumerator.equals(unspecializedEnumerators[i]))
 				return fEnumerators[i];
 		}
-		return null;
+		return enumerator;
 	}
 }

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPEnumerator.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2004, 2010 IBM Corporation and others.
+ * Copyright (c) 2004, 2014 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -8,32 +8,36 @@
  * Contributors:
  *     Andrew Niefer (IBM Corporation) - initial API and implementation
  *     Markus Schorn (Wind River Systems)
+ *     Sergey Prigogin (Google)
  *******************************************************************************/
 package org.eclipse.cdt.internal.core.dom.parser.cpp;
 
 import org.eclipse.cdt.core.dom.ILinkage;
 import org.eclipse.cdt.core.dom.ast.DOMException;
-import org.eclipse.cdt.core.dom.ast.IASTEnumerationSpecifier;
 import org.eclipse.cdt.core.dom.ast.IASTEnumerationSpecifier.IASTEnumerator;
 import org.eclipse.cdt.core.dom.ast.IASTName;
 import org.eclipse.cdt.core.dom.ast.IASTNode;
 import org.eclipse.cdt.core.dom.ast.IBinding;
-import org.eclipse.cdt.core.dom.ast.IEnumerator;
 import org.eclipse.cdt.core.dom.ast.IScope;
 import org.eclipse.cdt.core.dom.ast.IType;
 import org.eclipse.cdt.core.dom.ast.IValue;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPBlockScope;
+import org.eclipse.cdt.core.dom.ast.cpp.ICPPEnumeration;
 import org.eclipse.cdt.internal.core.dom.Linkage;
 import org.eclipse.cdt.internal.core.dom.parser.ASTEnumerator;
+import org.eclipse.cdt.internal.core.dom.parser.IASTInternalEnumerationSpecifier;
+import org.eclipse.cdt.internal.core.dom.parser.ProblemType;
 import org.eclipse.cdt.internal.core.dom.parser.Value;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor;
 import org.eclipse.core.runtime.PlatformObject;
 
 /**
- * Binding for a c++ enumerator.
+ * Binding for a C++ enumerator.
  */
-public class CPPEnumerator extends PlatformObject implements IEnumerator, ICPPInternalBinding {
+public class CPPEnumerator extends PlatformObject
+		implements ICPPInternalEnumerator, ICPPInternalBinding {
     private IASTName enumName;
+    private IType internalType;
 
     /**
      * @param enumerator
@@ -75,10 +79,38 @@ public class CPPEnumerator extends PlatformObject implements IEnumerator, ICPPIn
 	@Override
 	public IType getType() {
 	    IASTEnumerator etor = (IASTEnumerator) enumName.getParent();
-		IASTEnumerationSpecifier enumSpec = (IASTEnumerationSpecifier) etor.getParent();
+	    IASTInternalEnumerationSpecifier enumSpec = (IASTInternalEnumerationSpecifier) etor.getParent();
+		if (enumSpec.isValueComputationInProgress()) {
+		    // During value computation enumerators can be referenced only by initializer
+			// expressions of other enumerators of the same enumeration. Return the internal type
+			// of the enumerator ([dcl.enum] 7.2-5).
+			if (internalType != null)
+				return internalType;
+			ICPPEnumeration binding = (ICPPEnumeration) enumSpec.getName().resolveBinding();
+			IType fixedType = binding.getFixedType();
+			return fixedType != null ? fixedType : ProblemType.UNKNOWN_FOR_EXPRESSION;
+		}
 		return (IType) enumSpec.getName().resolveBinding();
 	}
 
+	@Override
+	public IType getInternalType() {
+		if (internalType == null) {
+			getValue();	// Trigger value and internal type computation.
+		}
+		return internalType;
+	}
+
+	/**
+	 * Sets the internal type of the enumerator. The enumerator has this type between the opening
+	 * and the closing braces of the enumeration ([dcl.enum] 7.2-5).
+	 *
+	 * @param type the integral type of the enumerator's initializing value
+	 */
+	public void setInternalType(IType type) {
+		internalType = type;
+	}
+
     @Override
 	public String[] getQualifiedName() {
         return CPPVisitor.getQualifiedName(this);

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/CPPEnumeratorSpecialization.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2013 Nathan Ridge.
+ * Copyright (c) 2013, 2014 Nathan Ridge.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -7,6 +7,7 @@
  *
  * Contributors:
  *     Nathan Ridge - Initial API and implementation
+ *     Sergey Prigogin (Google)
  *******************************************************************************/
 package org.eclipse.cdt.internal.core.dom.parser.cpp;
 
@@ -19,13 +20,15 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameterMap;
 /**
  * Binding for a specialization of an enumerator.
  */
-public class CPPEnumeratorSpecialization extends CPPSpecialization implements IEnumerator {
+public class CPPEnumeratorSpecialization extends CPPSpecialization implements ICPPInternalEnumerator {
 	private final IValue fValue;
+	private final IType fInternalType;
 
 	public CPPEnumeratorSpecialization(IEnumerator specialized, ICPPEnumerationSpecialization owner,
-			ICPPTemplateParameterMap argumentMap, IValue value) {
+			ICPPTemplateParameterMap argumentMap, IValue value, IType internalType) {
 		super(specialized, owner, argumentMap);
 		fValue = value;
+		fInternalType = internalType;
 	}
 
 	@Override
@@ -42,4 +45,9 @@ public class CPPEnumeratorSpecialization extends CPPSpecialization implements IE
 	public IValue getValue() {
 		return fValue;
 	}
+
+	@Override
+	public IType getInternalType() {
+		return fInternalType;
+	}
 }

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/ICPPInternalEnumerator.java

@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2014 Google, Inc and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * 	   Sergey Prigogin (Google) - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.cdt.internal.core.dom.parser.cpp;
+
+import org.eclipse.cdt.core.dom.ast.IEnumerator;
+import org.eclipse.cdt.core.dom.ast.IType;
+
+/**
+ * Non API methods for C++ enumerators.
+ */
+public interface ICPPInternalEnumerator extends IEnumerator {
+	/**
+	 * Returns the internal type of the enumerator. The enumerator has this type between the opening
+	 * and the closing braces of the enumeration ([dcl.enum] 7.2-5).
+	 *
+	 * @param type the integral type of the enumerator's initializing value
+	 */
+	IType getInternalType();
+}

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPTemplates.java

@@ -42,6 +42,7 @@ import org.eclipse.cdt.core.dom.ast.IASTNode;
 import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclaration;
 import org.eclipse.cdt.core.dom.ast.IASTTypeId;
 import org.eclipse.cdt.core.dom.ast.IArrayType;
+import org.eclipse.cdt.core.dom.ast.IBasicType;
 import org.eclipse.cdt.core.dom.ast.IBinding;
 import org.eclipse.cdt.core.dom.ast.IEnumerator;
 import org.eclipse.cdt.core.dom.ast.IFunctionType;
@@ -106,6 +107,7 @@ import org.eclipse.cdt.core.parser.util.ArrayUtil;
 import org.eclipse.cdt.core.parser.util.CharArraySet;
 import org.eclipse.cdt.core.parser.util.ObjectMap;
 import org.eclipse.cdt.internal.core.dom.parser.ASTAmbiguousNode;
+import org.eclipse.cdt.internal.core.dom.parser.ASTEnumerator;
 import org.eclipse.cdt.internal.core.dom.parser.ASTInternal;
 import org.eclipse.cdt.internal.core.dom.parser.ASTQueries;
 import org.eclipse.cdt.internal.core.dom.parser.IASTInternalScope;
@@ -116,6 +118,7 @@ import org.eclipse.cdt.internal.core.dom.parser.Value;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPASTName;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPAliasTemplateInstance;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPArrayType;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPBasicType;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPClassInstance;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPClassSpecialization;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPClassTemplatePartialSpecialization;
@@ -161,6 +164,7 @@ import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPEvaluation;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInstanceCache;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalBinding;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalClassTemplate;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalEnumerator;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPUnknownBinding;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPUnknownMember;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPUnknownMemberClass;
@@ -958,22 +962,7 @@ public class CPPTemplates {
 				IType type= instantiateType(aliasTemplate.getType(), tpMap, -1, getSpecializationContext(owner), point);
 			    spec = new CPPAliasTemplateInstance(decl.getNameCharArray(), aliasTemplate, type);
 			} else if (decl instanceof ICPPEnumeration) {
-				ICPPClassSpecialization within = getSpecializationContext(owner);
+				spec = instantiateEnumeration((ICPPEnumeration) decl, getSpecializationContext(owner), tpMap, point);
-				ICPPEnumeration enumeration = (ICPPEnumeration) decl;
-				IType fixedType = instantiateType(enumeration.getFixedType(), tpMap, -1, within, point);
-				CPPEnumerationSpecialization specializedEnumeration =
-						new CPPEnumerationSpecialization(enumeration, owner, tpMap, fixedType);
-				IEnumerator[] enumerators = enumeration.getEnumerators();
-				IEnumerator[] specializedEnumerators = new IEnumerator[enumerators.length];
-				for (int i = 0; i < enumerators.length; ++i) {
-					IEnumerator enumerator = enumerators[i];
-					IValue specializedValue =
-							instantiateValue(enumerator.getValue(), tpMap, -1, within, Value.MAX_RECURSION_DEPTH, point);
-					specializedEnumerators[i] =
-							new CPPEnumeratorSpecialization(enumerator, specializedEnumeration, tpMap, specializedValue);
-				}
-				specializedEnumeration.setEnumerators(specializedEnumerators);
-				spec = specializedEnumeration;
 			} else if (decl instanceof IEnumerator) {
 				IEnumerator enumerator = (IEnumerator) decl;
 				ICPPEnumeration enumeration = (ICPPEnumeration) enumerator.getOwner();
@@ -1008,6 +997,38 @@ public class CPPTemplates {
 		return spec;
 	}
 
+	private static IBinding instantiateEnumeration(ICPPEnumeration enumeration, ICPPClassSpecialization within,
+			final ICPPTemplateParameterMap tpMap, IASTNode point) {
+		IType fixedType = instantiateType(enumeration.getFixedType(), tpMap, -1, within, point);
+		CPPEnumerationSpecialization specializedEnumeration =
+				new CPPEnumerationSpecialization(enumeration, within, tpMap, fixedType);
+		IEnumerator[] enumerators = enumeration.getEnumerators();
+		IEnumerator[] specializedEnumerators = new IEnumerator[enumerators.length];
+		specializedEnumeration.setEnumerators(specializedEnumerators);
+		IType previousInternalType = CPPBasicType.INT;
+		for (int i = 0; i < enumerators.length; ++i) {
+			IEnumerator enumerator = enumerators[i];
+			IValue specializedValue =
+					instantiateValue(enumerator.getValue(), tpMap, -1, within, Value.MAX_RECURSION_DEPTH, point);
+			IType internalType = null;
+			if (fixedType == null && enumerator instanceof ICPPInternalEnumerator) {
+				internalType = ((ICPPInternalEnumerator) enumerator).getInternalType();
+				if (internalType != null) {
+					internalType = instantiateType(internalType, tpMap, -1, within, point);
+				} else {
+					if (previousInternalType instanceof IBasicType) {
+						internalType = ASTEnumerator.getTypeOfIncrementedValue((IBasicType) previousInternalType, specializedValue);
+					}						}
+				if (internalType != null) {
+					previousInternalType = internalType;
+				}
+			}
+			specializedEnumerators[i] =	new CPPEnumeratorSpecialization(enumerator,
+					specializedEnumeration, tpMap, specializedValue, internalType);
+		}
+		return specializedEnumeration;
+	}
+
 	private static ICPPClassSpecialization getSpecializationContext(IBinding owner) {
 		if (!(owner instanceof ICPPClassSpecialization))
 			return null;

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/CPPVisitor.java

@@ -81,7 +81,6 @@ import org.eclipse.cdt.core.dom.ast.IASTTypeId;
 import org.eclipse.cdt.core.dom.ast.IASTUnaryExpression;
 import org.eclipse.cdt.core.dom.ast.IArrayType;
 import org.eclipse.cdt.core.dom.ast.IBasicType;
-import org.eclipse.cdt.core.dom.ast.IBasicType.Kind;
 import org.eclipse.cdt.core.dom.ast.IBinding;
 import org.eclipse.cdt.core.dom.ast.ICompositeType;
 import org.eclipse.cdt.core.dom.ast.IEnumeration;
@@ -227,18 +226,6 @@ import org.eclipse.cdt.internal.core.index.IIndexScope;
  * Collection of methods to extract information from a C++ translation unit.
  */
 public class CPPVisitor extends ASTQueries {
-	public static final CPPBasicType SHORT_TYPE = new CPPBasicType(Kind.eInt, IBasicType.IS_SHORT);
-	public static final CPPBasicType INT_TYPE = new CPPBasicType(Kind.eInt, 0);
-	public static final CPPBasicType LONG_TYPE = new CPPBasicType(Kind.eInt, IBasicType.IS_LONG);
-	public static final CPPBasicType LONG_LONG_TYPE = new CPPBasicType(Kind.eInt, IBasicType.IS_LONG_LONG);
-	public static final CPPBasicType INT128_TYPE = new CPPBasicType(Kind.eInt128, 0);
-	
-	public static final CPPBasicType UNSIGNED_SHORT = new CPPBasicType(Kind.eInt, IBasicType.IS_SHORT | IBasicType.IS_UNSIGNED);
-	public static final CPPBasicType UNSIGNED_INT = new CPPBasicType(Kind.eInt, IBasicType.IS_UNSIGNED);
-	public static final CPPBasicType UNSIGNED_LONG = new CPPBasicType(Kind.eInt, IBasicType.IS_LONG | IBasicType.IS_UNSIGNED);
-	public static final CPPBasicType UNSIGNED_LONG_LONG = new CPPBasicType(Kind.eInt, IBasicType.IS_LONG_LONG | IBasicType.IS_UNSIGNED);
-	public static final CPPBasicType UNSIGNED_INT128 = new CPPBasicType(Kind.eInt128, IBasicType.IS_UNSIGNED);
-
 	public static final String BEGIN_STR = "begin"; //$NON-NLS-1$
 	public static final char[] BEGIN = BEGIN_STR.toCharArray();
 	public static final char[] END = "end".toCharArray();  //$NON-NLS-1$
@@ -481,6 +468,13 @@ public class CPPVisitor extends ASTQueries {
 			}
 			return new ProblemBinding(name, IProblemBinding.SEMANTIC_INVALID_REDECLARATION);
 		}
+		// [dcl.enum] 7.2-5
+		// "The underlying type can be explicitly specified using enum-base;
+		// if not explicitly specified, the underlying type of a scoped
+		// enumeration type is int."
+		if (fixedType == null && specifier.isScoped()) {
+			fixedType = CPPBasicType.INT;
+		}
 		return new CPPEnumeration(specifier, fixedType);
     }
 
@@ -2356,7 +2350,7 @@ public class CPPVisitor extends ASTQueries {
 
 	public static IType getPointerDiffType(final IASTNode point) {
 		IType t= getStdType(point, PTRDIFF_T);
-		return t != null ? t : LONG_TYPE;
+		return t != null ? t : CPPBasicType.LONG;
 	}
 
 	private static IType getStdType(final IASTNode node, char[] name) {
@@ -2382,12 +2376,12 @@ public class CPPVisitor extends ASTQueries {
 
 	public static IType get_type_info(IASTNode point) {
 		IType t= getStdType(point, TYPE_INFO);
-		return t != null ? t : INT_TYPE;
+		return t != null ? t : CPPBasicType.INT;
 	}
 
 	public static IType get_SIZE_T(IASTNode sizeofExpr) {
 		IType t= getStdType(sizeofExpr, SIZE_T);
-		return t != null ? t : UNSIGNED_LONG;
+		return t != null ? t : CPPBasicType.UNSIGNED_LONG;
 	}
 
 	public static ICPPClassTemplate get_initializer_list(IASTNode node) {

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/EvalID.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2012, 2013 Wind River Systems, Inc. and others.
+ * Copyright (c) 2012, 2014 Wind River Systems, Inc. and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -20,6 +20,7 @@ import static org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.SemanticUti
 import static org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.SemanticUtil.getNestedType;
 
 import org.eclipse.cdt.core.dom.ast.DOMException;
+import org.eclipse.cdt.core.dom.ast.IASTEnumerationSpecifier.IASTEnumerator;
 import org.eclipse.cdt.core.dom.ast.IASTExpression;
 import org.eclipse.cdt.core.dom.ast.IASTExpression.ValueCategory;
 import org.eclipse.cdt.core.dom.ast.IASTIdExpression;
@@ -53,6 +54,7 @@ import org.eclipse.cdt.internal.core.dom.parser.ITypeMarshalBuffer;
 import org.eclipse.cdt.internal.core.dom.parser.Value;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPDeferredFunction;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPEvaluation;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalEnumerator;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPUnknownBinding;
 import org.eclipse.core.runtime.CoreException;
 
@@ -253,14 +255,13 @@ public class EvalID extends CPPDependentEvaluation {
 			IType type= ((IEnumerator) binding).getType();
 			if (type instanceof ICPPEnumeration) {
 				ICPPEnumeration enumType= (ICPPEnumeration) type;
-				if (enumType.asScope() == CPPVisitor.getContainingScope(expr)) {
+				// [dcl.enum] 7.2-5
-					// C++0x: 7.2-5
+				if (isInsideEnum(expr, enumType)) {
-					type= enumType.getFixedType();
+					if (binding instanceof ICPPInternalEnumerator) {
-					if (type == null) {
+						type = enumType.getFixedType();
-						// This is a simplification, the actual type is determined
+						if (type == null) {
-						// - in an implementation dependent manner - by the value
+							type = ((ICPPInternalEnumerator) binding).getInternalType();
-						// of the enumerator.
+						}
-						type= CPPSemantics.INT_TYPE;
 					}
 					return new EvalBinding(binding, type, expr);
 				}
@@ -274,6 +275,17 @@ public class EvalID extends CPPDependentEvaluation {
 		return EvalFixed.INCOMPLETE;
 	}
 
+	/**
+	 * Returns {@code true} if the given node is located inside the given enum.
+	 */
+	private static boolean isInsideEnum(IASTNode node, ICPPEnumeration enumBinding) {
+		IASTEnumerator enumeratorNode = CPPVisitor.findAncestorWithType(node, IASTEnumerator.class);
+		if (enumeratorNode == null)
+			return false;
+		IBinding enumerator = enumeratorNode.getName().getBinding();
+		return enumerator != null && enumBinding == enumerator.getOwner();
+	}
+
 	private static IType withinNonStaticMethod(IASTExpression expr) {
 		IASTNode parent= expr.getParent();
 		while (parent != null && !(parent instanceof ICPPASTFunctionDefinition)) {

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/dom/parser/cpp/semantics/TypeTraits.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2012 Google, Inc and others.
+ * Copyright (c) 2012, 2014 Google, Inc and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -30,6 +30,7 @@ import org.eclipse.cdt.core.dom.ast.cpp.ICPPUnaryTypeTransformation.Operator;
 import org.eclipse.cdt.core.dom.ast.cpp.SemanticQueries;
 import org.eclipse.cdt.internal.core.dom.parser.ArithmeticConversion;
 import org.eclipse.cdt.internal.core.dom.parser.ProblemType;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPBasicType;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPUnaryTypeTransformation;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ClassTypeHelper;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ClassTypeHelper.MethodKind;
@@ -38,6 +39,19 @@ import org.eclipse.cdt.internal.core.dom.parser.cpp.ClassTypeHelper.MethodKind;
  * A collection of static methods for determining type traits.
  */
 public class TypeTraits {
+	private static final ICPPBasicType[] SIGNED_UNDERLYING_ENUM_TYPES = {
+		CPPBasicType.INT,
+		CPPBasicType.LONG,
+		CPPBasicType.LONG_LONG,
+		CPPBasicType.INT128
+	};
+	private static final ICPPBasicType[] UNSIGNED_UNDERLYING_ENUM_TYPES = {
+		CPPBasicType.UNSIGNED_INT,
+		CPPBasicType.UNSIGNED_LONG,
+		CPPBasicType.UNSIGNED_LONG_LONG,
+		CPPBasicType.UNSIGNED_INT128
+	};
+
 	private TypeTraits() {}
 
 	/**
@@ -342,17 +356,11 @@ public class TypeTraits {
 		} else {
 			ICPPEnumeration enumeration = (ICPPEnumeration) type;
 
-			// [dcl.enum] p5
-			// "The underlying type can be explicitly specified using enum-base;
-			// if not explicitly specified, the underlying type of a scoped
-			// enumeration type is int."
 			IType fixedType = enumeration.getFixedType();
 			if (fixedType != null)
 				return fixedType;
-			if (enumeration.isScoped())
-				return CPPVisitor.INT_TYPE;
 			
-			// [dcl.enum] p6
+			// [dcl.enum] 7.2-6:
 			// "For an enumeration whose underlying type is not fixed, the
 			// underlying type is an integral type that can represent all
 			// the numerator values defined in the enumeration. ... It is
@@ -363,28 +371,22 @@ public class TypeTraits {
 			// the underlying type is as if the enumeration had a single
 			// enumerator with value 0."
 			if (enumeration.getEnumerators().length == 0)
-				return CPPVisitor.INT_TYPE;
+				return CPPBasicType.INT;
-			if (enumeration.getMinValue() < 0 || enumeration.getMaxValue() < 0) {
+			long minValue = enumeration.getMinValue();
-				return smallestFittingType(enumeration,
+			long maxValue = enumeration.getMaxValue();
-						CPPVisitor.INT_TYPE, 
+			if (minValue < 0 || maxValue < 0) {
-						CPPVisitor.LONG_TYPE, 
+				return smallestFittingType(minValue, maxValue, SIGNED_UNDERLYING_ENUM_TYPES);
-						CPPVisitor.LONG_LONG_TYPE,
-						CPPVisitor.INT128_TYPE);
 			} else {
-				return smallestFittingType(enumeration,
+				return smallestFittingType(minValue, maxValue, UNSIGNED_UNDERLYING_ENUM_TYPES);
-						CPPVisitor.UNSIGNED_INT, 
-						CPPVisitor.UNSIGNED_LONG, 
-						CPPVisitor.UNSIGNED_LONG_LONG,
-						CPPVisitor.UNSIGNED_INT128);
 			}
 		}
 	}
-	
+
-	private static IBasicType smallestFittingType(ICPPEnumeration enumeration, ICPPBasicType... types) {
+	private static IBasicType smallestFittingType(long minValue, long maxValue, ICPPBasicType[] types) {
-		for (int i = 0; i < types.length - 1; ++i) {
+		for (ICPPBasicType type : types) {
-			if (ArithmeticConversion.fitsIntoType(types[i], enumeration.getMinValue())
+			if (ArithmeticConversion.fitsIntoType(type, minValue)
-					&& ArithmeticConversion.fitsIntoType(types[i], enumeration.getMaxValue())) {
+					&& ArithmeticConversion.fitsIntoType(type, maxValue)) {
-				return types[i];
+				return type;
 			}
 		}
 		return types[types.length - 1];  // Assume it fits into the largest type provided.

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/index/composite/cpp/CPPCompositesFactory.java

@@ -16,7 +16,6 @@ import org.eclipse.cdt.core.CCorePlugin;
 import org.eclipse.cdt.core.dom.ast.IArrayType;
 import org.eclipse.cdt.core.dom.ast.IBasicType;
 import org.eclipse.cdt.core.dom.ast.IBinding;
-import org.eclipse.cdt.core.dom.ast.IEnumerator;
 import org.eclipse.cdt.core.dom.ast.IPointerType;
 import org.eclipse.cdt.core.dom.ast.IProblemBinding;
 import org.eclipse.cdt.core.dom.ast.IQualifierType;
@@ -74,6 +73,7 @@ import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPUnaryTypeTransformation;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPClassSpecializationScope;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPDeferredClassInstance;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPEvaluation;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalEnumerator;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPUnknownBinding;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPUnknownMember;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPUnknownMemberClass;
@@ -578,8 +578,8 @@ public class CPPCompositesFactory extends AbstractCompositeFactory {
 						return new CompositeCPPUsingDeclarationSpecialization(this, (ICPPUsingDeclaration) binding);
 					} else if (binding instanceof ICPPEnumeration) {
 						return new CompositeCPPEnumerationSpecialization(this, (ICPPEnumeration) binding);
-					} else if (binding instanceof IEnumerator) {
+					} else if (binding instanceof ICPPInternalEnumerator) {
-						return new CompositeCPPEnumeratorSpecialization(this, (IEnumerator) binding);
+						return new CompositeCPPEnumeratorSpecialization(this, (ICPPInternalEnumerator) binding);
 					} else {
 						throw new CompositingNotImplementedError("Composite binding unavailable for " + binding + " " + binding.getClass()); //$NON-NLS-1$ //$NON-NLS-2$
 					}
@@ -655,8 +655,8 @@ public class CPPCompositesFactory extends AbstractCompositeFactory {
 				result = def == null ? null : new CompositeCPPEnumeration(this, def);
 			} else if (binding instanceof ICPPFunction) {
 				result = new CompositeCPPFunction(this, (ICPPFunction) binding);				
-			} else if (binding instanceof IEnumerator) {
+			} else if (binding instanceof ICPPInternalEnumerator) {
-				result = new CompositeCPPEnumerator(this, (IEnumerator) binding);
+				result = new CompositeCPPEnumerator(this, (ICPPInternalEnumerator) binding);
 			} else if (binding instanceof ITypedef) {
 				result = new CompositeCPPTypedef(this, (ICPPBinding) binding);
 			} else if (binding instanceof IIndexMacroContainer) {

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/index/composite/cpp/CompositeCPPEnumerator.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2009 Symbian Software Systems and others.
+ * Copyright (c) 2007, 2014 Symbian Software Systems and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -7,32 +7,38 @@
  *
  * Contributors:
  *     Andrew Ferguson (Symbian) - Initial implementation
+ *     Sergey Prigogin (Google)
  *******************************************************************************/
 package org.eclipse.cdt.internal.core.index.composite.cpp;
 
-import org.eclipse.cdt.core.dom.ast.IEnumerator;
 import org.eclipse.cdt.core.dom.ast.IType;
 import org.eclipse.cdt.core.dom.ast.IValue;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalEnumerator;
 import org.eclipse.cdt.internal.core.index.composite.ICompositesFactory;
 
-class CompositeCPPEnumerator extends CompositeCPPBinding implements IEnumerator {
+class CompositeCPPEnumerator extends CompositeCPPBinding implements ICPPInternalEnumerator {
-	public CompositeCPPEnumerator(ICompositesFactory cf, IEnumerator rbinding) {
+	public CompositeCPPEnumerator(ICompositesFactory cf, ICPPInternalEnumerator rbinding) {
 		super(cf, rbinding);
 	}
 
 	@Override
 	public IType getType() {
-		IType type = ((IEnumerator) rbinding).getType();
+		IType type = ((ICPPInternalEnumerator) rbinding).getType();
 		return cf.getCompositeType(type);
 	}
 	
 	@Override
 	public IValue getValue() {
-		return ((IEnumerator) rbinding).getValue();
+		return ((ICPPInternalEnumerator) rbinding).getValue();
 	}
 
 	@Override
 	public String toString() {
 		return getName();
 	}
+
+	@Override
+	public IType getInternalType() {
+		return ((ICPPInternalEnumerator) rbinding).getInternalType();
+	}
 }

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/index/composite/cpp/CompositeCPPEnumeratorSpecialization.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2013 Google, Inc and others.
+ * Copyright (c) 2013, 2014 Google, Inc and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -11,15 +11,15 @@
 package org.eclipse.cdt.internal.core.index.composite.cpp;
 
 import org.eclipse.cdt.core.dom.ast.IBinding;
-import org.eclipse.cdt.core.dom.ast.IEnumerator;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateParameterMap;
 import org.eclipse.cdt.core.parser.util.ObjectMap;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPTemplateParameterMap;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalEnumerator;
 import org.eclipse.cdt.internal.core.index.composite.ICompositesFactory;
 
 class CompositeCPPEnumeratorSpecialization extends CompositeCPPEnumerator implements ICPPSpecialization {
-	public CompositeCPPEnumeratorSpecialization(ICompositesFactory cf, IEnumerator delegate) {
+	public CompositeCPPEnumeratorSpecialization(ICompositesFactory cf, ICPPInternalEnumerator delegate) {
 		super(cf, delegate);
 	}
 

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/PDOM.java

@@ -251,11 +251,14 @@ public class PDOM extends PlatformObject implements IPDOM {
 	 *  CDT 8.4 development (versions not supported on the 8.3.x branch)
 	 *  170.0 - Unconditionally store arguments of EvalTypeId, bug 430230.
 	 *  171.0 - Replacement headers for Organize Includes, bug 414692.
-	 *  172.0 - Store default values for function parameters, bug 432701.
+	 *  #172.0# - Store default values for function parameters, bug 432701. <<CDT 8.4>>
+	 *
+	 *  CDT 8.6 development (versions not supported on the 8.5.x branch)
+	 *  180.0 - Internal types of enumerators, bug 446711.
 	 */
-	private static final int MIN_SUPPORTED_VERSION= version(172, 0);
+	private static final int MIN_SUPPORTED_VERSION= version(180, 0);
-	private static final int MAX_SUPPORTED_VERSION= version(172, Short.MAX_VALUE);
+	private static final int MAX_SUPPORTED_VERSION= version(180, Short.MAX_VALUE);
-	private static final int DEFAULT_VERSION = version(172, 0);
+	private static final int DEFAULT_VERSION = version(180, 0);
 
 	private static int version(int major, int minor) {
 		return (major << 16) + minor;

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/IPDOMCPPEnumerator.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2013 Google, Inc and others.
+ * Copyright (c) 2013, 2014 Google, Inc and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -10,11 +10,11 @@
  *******************************************************************************/
 package org.eclipse.cdt.internal.core.pdom.dom.cpp;
 
-import org.eclipse.cdt.core.dom.ast.IEnumerator;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalEnumerator;
 import org.eclipse.cdt.internal.core.pdom.dom.IPDOMBinding;
 
 /**
  * Interface for a c++ enumerator stored in the index.
  */
-public interface IPDOMCPPEnumerator extends IEnumerator, IPDOMBinding {
+public interface IPDOMCPPEnumerator extends ICPPInternalEnumerator, IPDOMBinding {
 }

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPEnumerationSpecialization.java

@@ -258,6 +258,6 @@ class PDOMCPPEnumerationSpecialization extends PDOMCPPSpecialization
 				return i < enumerators.length ? enumerators[i] : enumerator;
 			}
 		}
-		return null;
+		return enumerator;
 	}
 }

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPEnumerator.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2006, 2013 QNX Software Systems and others.
+ * Copyright (c) 2006, 2014 QNX Software Systems and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -17,7 +17,9 @@ import org.eclipse.cdt.core.dom.ast.IBinding;
 import org.eclipse.cdt.core.dom.ast.IEnumerator;
 import org.eclipse.cdt.core.dom.ast.IType;
 import org.eclipse.cdt.core.dom.ast.IValue;
+import org.eclipse.cdt.internal.core.dom.parser.ProblemType;
 import org.eclipse.cdt.internal.core.dom.parser.Value;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalEnumerator;
 import org.eclipse.cdt.internal.core.index.IIndexCPPBindingConstants;
 import org.eclipse.cdt.internal.core.index.IIndexFragmentBinding;
 import org.eclipse.cdt.internal.core.pdom.db.Database;
@@ -30,14 +32,22 @@ import org.eclipse.core.runtime.CoreException;
  */
 class PDOMCPPEnumerator extends PDOMCPPBinding implements IPDOMCPPEnumerator {
 	private static final int VALUE= PDOMCPPBinding.RECORD_SIZE;
+	private static final int INTERNAL_TYPE= VALUE + Database.VALUE_SIZE;
 	
 	@SuppressWarnings("hiding")
-	protected static final int RECORD_SIZE = VALUE + Database.VALUE_SIZE;
+	protected static final int RECORD_SIZE = INTERNAL_TYPE + Database.TYPE_SIZE;
 		
-	public PDOMCPPEnumerator(PDOMLinkage linkage, PDOMNode parent, IEnumerator enumerator)
+	public PDOMCPPEnumerator(PDOMLinkage linkage, PDOMNode parent, ICPPInternalEnumerator enumerator)
 			throws CoreException {
 		super(linkage, parent, enumerator.getNameCharArray());
-		storeValue(enumerator);
+		IValue value= enumerator.getValue();
+		if (value != null) {
+			linkage.storeValue(record + VALUE, value);
+		}
+		IType internalType = enumerator.getInternalType();
+		if (internalType != null) {
+			linkage.storeType(record + INTERNAL_TYPE, internalType);
+		}
 	}
 
 	public PDOMCPPEnumerator(PDOMLinkage linkage, long record) {
@@ -54,17 +64,14 @@ class PDOMCPPEnumerator extends PDOMCPPBinding implements IPDOMCPPEnumerator {
 		return IIndexCPPBindingConstants.CPPENUMERATOR;
 	}
 
-	private void storeValue(IEnumerator enumerator) throws CoreException {
-		IValue value= enumerator.getValue();
-		if (value != null) {
-			getLinkage().storeValue(record + VALUE, value);
-		}
-	}
-
 	@Override
 	public void update(PDOMLinkage linkage, IBinding newBinding) throws CoreException {
-		if (newBinding instanceof IEnumerator)
+		if (newBinding instanceof IEnumerator) {
-			storeValue((IEnumerator) newBinding);
+			IValue value= ((IEnumerator) newBinding).getValue();
+			if (value != null) {
+				getLinkage().storeValue(record + VALUE, value);
+			}
+		}
 	}
 
 	@Override
@@ -74,7 +81,17 @@ class PDOMCPPEnumerator extends PDOMCPPBinding implements IPDOMCPPEnumerator {
 			return (IType) owner;
 		return null;
 	}
-	
+
+	@Override
+	public IType getInternalType() {
+		try {
+			return getLinkage().loadType(record + INTERNAL_TYPE);
+		} catch (CoreException e) {
+			CCorePlugin.log(e);
+		}
+		return ProblemType.UNKNOWN_FOR_EXPRESSION;
+	}
+
 	@Override
 	public IValue getValue() {
 		try {

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPEnumeratorSpecialization.java

@@ -16,7 +16,9 @@ import org.eclipse.cdt.core.dom.ast.IEnumerator;
 import org.eclipse.cdt.core.dom.ast.IType;
 import org.eclipse.cdt.core.dom.ast.IValue;
 import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
+import org.eclipse.cdt.internal.core.dom.parser.ProblemType;
 import org.eclipse.cdt.internal.core.dom.parser.Value;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalEnumerator;
 import org.eclipse.cdt.internal.core.index.IIndexCPPBindingConstants;
 import org.eclipse.cdt.internal.core.index.IIndexFragmentBinding;
 import org.eclipse.cdt.internal.core.pdom.db.Database;
@@ -30,14 +32,22 @@ import org.eclipse.core.runtime.CoreException;
  */
 class PDOMCPPEnumeratorSpecialization extends PDOMCPPSpecialization implements IPDOMCPPEnumerator {
 	private static final int VALUE= PDOMCPPSpecialization.RECORD_SIZE;
+	private static final int INTERNAL_TYPE= VALUE + Database.VALUE_SIZE;
 
 	@SuppressWarnings("hiding")
-	protected static final int RECORD_SIZE = VALUE + Database.VALUE_SIZE;
+	protected static final int RECORD_SIZE = INTERNAL_TYPE + Database.TYPE_SIZE;
 
 	public PDOMCPPEnumeratorSpecialization(PDOMCPPLinkage linkage, PDOMNode parent,
-			IEnumerator enumerator, PDOMBinding specialized) throws CoreException {
+			ICPPInternalEnumerator enumerator, PDOMBinding specialized) throws CoreException {
 		super(linkage, parent, (ICPPSpecialization) enumerator, specialized);
-		storeValue(enumerator);
+		IValue value= enumerator.getValue();
+		if (value != null) {
+			getLinkage().storeValue(record + VALUE, value);
+		}
+		IType internalType = enumerator.getInternalType();
+		if (internalType != null) {
+			linkage.storeType(record + INTERNAL_TYPE, internalType);
+		}
 	}
 
 	public PDOMCPPEnumeratorSpecialization(PDOMLinkage linkage, long record) {
@@ -54,17 +64,14 @@ class PDOMCPPEnumeratorSpecialization extends PDOMCPPSpecialization implements I
 		return IIndexCPPBindingConstants.CPP_ENUMERATOR_SPECIALIZATION;
 	}
 
-	private void storeValue(IEnumerator enumerator) throws CoreException {
-		IValue value= enumerator.getValue();
-		if (value != null) {
-			getLinkage().storeValue(record + VALUE, value);
-		}
-	}
-
 	@Override
 	public void update(PDOMLinkage linkage, IBinding newBinding) throws CoreException {
-		if (newBinding instanceof IEnumerator)
+		if (newBinding instanceof IEnumerator) {
-			storeValue((IEnumerator) newBinding);
+			IValue value= ((IEnumerator) newBinding).getValue();
+			if (value != null) {
+				getLinkage().storeValue(record + VALUE, value);
+			}
+		}
 	}
 
 	@Override
@@ -75,6 +82,16 @@ class PDOMCPPEnumeratorSpecialization extends PDOMCPPSpecialization implements I
 		return null;
 	}
 
+	@Override
+	public IType getInternalType() {
+		try {
+			return getLinkage().loadType(record + INTERNAL_TYPE);
+		} catch (CoreException e) {
+			CCorePlugin.log(e);
+		}
+		return ProblemType.UNKNOWN_FOR_EXPRESSION;
+	}
+
 	@Override
 	public IValue getValue() {
 		try {

core/org.eclipse.cdt.core/parser/org/eclipse/cdt/internal/core/pdom/dom/cpp/PDOMCPPLinkage.java

@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2005, 2013 QNX Software Systems and others.
+ * Copyright (c) 2005, 2014 QNX Software Systems and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
@@ -101,6 +101,7 @@ import org.eclipse.cdt.internal.core.dom.parser.cpp.CPPUnknownMember;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ClassTypeHelper;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPDeferredClassInstance;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPEvaluation;
+import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPInternalEnumerator;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPUnknownBinding;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor;
 import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.EvalBinary;
@@ -539,9 +540,9 @@ class PDOMCPPLinkage extends PDOMLinkage implements IIndexCPPBindingConstants {
 			pdomBinding = new PDOMCPPUsingDeclaration(this, parent, (ICPPUsingDeclaration) binding);
 		} else if (binding instanceof ICPPEnumeration) {
 			pdomBinding = new PDOMCPPEnumeration(this, parent, (ICPPEnumeration) binding);
-		} else if (binding instanceof IEnumerator) {
+		} else if (binding instanceof ICPPInternalEnumerator) {
 			assert parent instanceof ICPPEnumeration;
-			pdomBinding = new PDOMCPPEnumerator(this, parent, (IEnumerator) binding);
+			pdomBinding = new PDOMCPPEnumerator(this, parent, (ICPPInternalEnumerator) binding);
 			if (parent instanceof ICPPEnumeration && !((ICPPEnumeration) parent).isScoped()) {
 				parent2= parent.getParentNode();
 				if (parent2 == null) {
@@ -673,8 +674,8 @@ class PDOMCPPLinkage extends PDOMLinkage implements IIndexCPPBindingConstants {
 			result= new PDOMCPPUsingDeclarationSpecialization(this, parent, (ICPPUsingDeclaration) special, orig);
 		} else if (special instanceof ICPPEnumeration) {
 			result= new PDOMCPPEnumerationSpecialization(this, parent, (ICPPEnumeration) special, orig);
-		} else if (special instanceof IEnumerator) {
+		} else if (special instanceof ICPPInternalEnumerator) {
-			result= new PDOMCPPEnumeratorSpecialization(this, parent, (IEnumerator) special, orig);
+			result= new PDOMCPPEnumeratorSpecialization(this, parent, (ICPPInternalEnumerator) special, orig);
 		}
 
 		return result;
@@ -685,7 +686,7 @@ class PDOMCPPLinkage extends PDOMLinkage implements IIndexCPPBindingConstants {
 			final long fileLocalRec= type.getLocalToFileRec();
 			IScope scope = binding.getCompositeScope();
 			if (scope instanceof ICPPClassScope) {
-				List<ICPPMethod> old= new ArrayList<ICPPMethod>();
+				List<ICPPMethod> old= new ArrayList<>();
 				if (type instanceof ICPPClassType) {
 					ArrayUtil.addAll(old, ClassTypeHelper.getImplicitMethods((ICPPClassType) type, point));
 				}