Remove the ConstantArrayType subtypes. This information is preserved in the

TypeLoc records for declarations;  it should not be necessary to represent it
directly in the type system.

Please complain if you were using these classes and feel you can't replicate
previous functionality using the TypeLoc API.

llvm-svn: 84222

10 files changed, 9 insertions, 239 deletions

diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index e028186d46e..507baeab27a 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -571,8 +571,6 @@ ASTContext::getTypeInfo(const Type *T) {
     Align = getTypeAlign(cast<ArrayType>(T)->getElementType());
     break;
 
-  case Type::ConstantArrayWithExpr:
-  case Type::ConstantArrayWithoutExpr:
   case Type::ConstantArray: {
     const ConstantArrayType *CAT = cast<ConstantArrayType>(T);
 
@@ -1358,53 +1356,6 @@ QualType ASTContext::getConstantArrayType(QualType EltTy,
   return QualType(New, 0);
 }
 
-/// getConstantArrayWithExprType - Return a reference to the type for
-/// an array of the specified element type.
-QualType
-ASTContext::getConstantArrayWithExprType(QualType EltTy,
-                                         const llvm::APInt &ArySizeIn,
-                                         Expr *ArySizeExpr,
-                                         ArrayType::ArraySizeModifier ASM,
-                                         unsigned EltTypeQuals,
-                                         SourceRange Brackets) {
-  // Convert the array size into a canonical width matching the pointer
-  // size for the target.
-  llvm::APInt ArySize(ArySizeIn);
-  ArySize.zextOrTrunc(Target.getPointerWidth(EltTy.getAddressSpace()));
-
-  // Compute the canonical ConstantArrayType.
-  QualType Canonical = getConstantArrayType(getCanonicalType(EltTy),
-                                            ArySize, ASM, EltTypeQuals);
-  // Since we don't unique expressions, it isn't possible to unique VLA's
-  // that have an expression provided for their size.
-  ConstantArrayWithExprType *New = new(*this, TypeAlignment)
-    ConstantArrayWithExprType(EltTy, Canonical, ArySize, ArySizeExpr,
-                              ASM, EltTypeQuals, Brackets);
-  Types.push_back(New);
-  return QualType(New, 0);
-}
-
-/// getConstantArrayWithoutExprType - Return a reference to the type for
-/// an array of the specified element type.
-QualType
-ASTContext::getConstantArrayWithoutExprType(QualType EltTy,
-                                            const llvm::APInt &ArySizeIn,
-                                            ArrayType::ArraySizeModifier ASM,
-                                            unsigned EltTypeQuals) {
-  // Convert the array size into a canonical width matching the pointer
-  // size for the target.
-  llvm::APInt ArySize(ArySizeIn);
-  ArySize.zextOrTrunc(Target.getPointerWidth(EltTy.getAddressSpace()));
-
-  // Compute the canonical ConstantArrayType.
-  QualType Canonical = getConstantArrayType(getCanonicalType(EltTy),
-                                            ArySize, ASM, EltTypeQuals);
-  ConstantArrayWithoutExprType *New = new(*this, TypeAlignment)
-    ConstantArrayWithoutExprType(EltTy, Canonical, ArySize, ASM, EltTypeQuals);
-  Types.push_back(New);
-  return QualType(New, 0);
-}
-
 /// getVariableArrayType - Returns a non-unique reference to the type for a
 /// variable array of the specified element type.
 QualType ASTContext::getVariableArrayType(QualType EltTy,
diff --git a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
index 0293862baed..bb9f57b6d1c 100644
--- a/clang/lib/AST/Type.cpp
+++ b/clang/lib/AST/Type.cpp
@@ -37,18 +37,6 @@ void Type::Destroy(ASTContext& C) {
   C.Deallocate(this);
 }
 
-void ConstantArrayWithExprType::Destroy(ASTContext& C) {
-  // FIXME: destruction of SizeExpr commented out due to resource contention.
-  // SizeExpr->Destroy(C);
-  // See FIXME in SemaDecl.cpp:1536: if we were able to either steal
-  // or clone the SizeExpr there, then here we could freely delete it.
-  // Since we do not know how to steal or clone, we keep a pointer to
-  // a shared resource, but we cannot free it.
-  // (There probably is a trivial solution ... for people knowing clang!).
-  this->~ConstantArrayWithExprType();
-  C.Deallocate(this);
-}
-
 void VariableArrayType::Destroy(ASTContext& C) {
   if (SizeExpr)
     SizeExpr->Destroy(C);
@@ -177,8 +165,6 @@ bool Type::isDerivedType() const {
   case Pointer:
   case VariableArray:
   case ConstantArray:
-  case ConstantArrayWithExpr:
-  case ConstantArrayWithoutExpr:
   case IncompleteArray:
   case FunctionProto:
   case FunctionNoProto:
@@ -1111,29 +1097,6 @@ void ConstantArrayType::getAsStringInternal(std::string &S, const PrintingPolicy
   getElementType().getAsStringInternal(S, Policy);
 }
 
-void ConstantArrayWithExprType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const {
-  if (Policy.ConstantArraySizeAsWritten) {
-    std::string SStr;
-    llvm::raw_string_ostream s(SStr);
-    getSizeExpr()->printPretty(s, 0, Policy);
-    S += '[';
-    S += s.str();
-    S += ']';
-    getElementType().getAsStringInternal(S, Policy);
-  }
-  else
-    ConstantArrayType::getAsStringInternal(S, Policy);
-}
-
-void ConstantArrayWithoutExprType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const {
-  if (Policy.ConstantArraySizeAsWritten) {
-    S += "[]";
-    getElementType().getAsStringInternal(S, Policy);
-  }
-  else
-    ConstantArrayType::getAsStringInternal(S, Policy);
-}
-
 void IncompleteArrayType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const {
   S += "[]";
 
diff --git a/clang/lib/CodeGen/CGDebugInfo.cpp b/clang/lib/CodeGen/CGDebugInfo.cpp
index 4c624205b4c..0e7318c6b77 100644
--- a/clang/lib/CodeGen/CGDebugInfo.cpp
+++ b/clang/lib/CodeGen/CGDebugInfo.cpp
@@ -846,8 +846,6 @@ llvm::DIType CGDebugInfo::CreateTypeNode(QualType Ty,
                            Unit);
 
   case Type::ConstantArray:
-  case Type::ConstantArrayWithExpr:
-  case Type::ConstantArrayWithoutExpr:
   case Type::VariableArray:
   case Type::IncompleteArray:
     return CreateType(cast<ArrayType>(Ty), Unit);
diff --git a/clang/lib/Frontend/PCHReader.cpp b/clang/lib/Frontend/PCHReader.cpp
index e61668dd317..d9d3960f6fd 100644
--- a/clang/lib/Frontend/PCHReader.cpp
+++ b/clang/lib/Frontend/PCHReader.cpp
@@ -1839,30 +1839,6 @@ QualType PCHReader::ReadTypeRecord(uint64_t Offset) {
                                          ASM, IndexTypeQuals);
   }
 
-  case pch::TYPE_CONSTANT_ARRAY_WITH_EXPR: {
-    QualType ElementType = GetType(Record[0]);
-    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
-    unsigned IndexTypeQuals = Record[2];
-    SourceLocation LBLoc = SourceLocation::getFromRawEncoding(Record[3]);
-    SourceLocation RBLoc = SourceLocation::getFromRawEncoding(Record[4]);
-    unsigned Idx = 5;
-    llvm::APInt Size = ReadAPInt(Record, Idx);
-    return Context->getConstantArrayWithExprType(ElementType,
-                                                 Size, ReadTypeExpr(),
-                                                 ASM, IndexTypeQuals,
-                                                 SourceRange(LBLoc, RBLoc));
-  }
-
-  case pch::TYPE_CONSTANT_ARRAY_WITHOUT_EXPR: {
-    QualType ElementType = GetType(Record[0]);
-    ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
-    unsigned IndexTypeQuals = Record[2];
-    unsigned Idx = 3;
-    llvm::APInt Size = ReadAPInt(Record, Idx);
-    return Context->getConstantArrayWithoutExprType(ElementType, Size,
-                                                    ASM, IndexTypeQuals);
-  }
-
   case pch::TYPE_INCOMPLETE_ARRAY: {
     QualType ElementType = GetType(Record[0]);
     ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
diff --git a/clang/lib/Frontend/PCHWriter.cpp b/clang/lib/Frontend/PCHWriter.cpp
index 64a678ea450..5d5e09bc667 100644
--- a/clang/lib/Frontend/PCHWriter.cpp
+++ b/clang/lib/Frontend/PCHWriter.cpp
@@ -117,23 +117,6 @@ void PCHTypeWriter::VisitConstantArrayType(const ConstantArrayType *T) {
   Code = pch::TYPE_CONSTANT_ARRAY;
 }
 
-void PCHTypeWriter
-::VisitConstantArrayWithExprType(const ConstantArrayWithExprType *T) {
-  VisitArrayType(T);
-  Writer.AddSourceLocation(T->getLBracketLoc(), Record);
-  Writer.AddSourceLocation(T->getRBracketLoc(), Record);
-  Writer.AddAPInt(T->getSize(), Record);
-  Writer.AddStmt(T->getSizeExpr());
-  Code = pch::TYPE_CONSTANT_ARRAY_WITH_EXPR;
-}
-
-void PCHTypeWriter
-::VisitConstantArrayWithoutExprType(const ConstantArrayWithoutExprType *T) {
-  VisitArrayType(T);
-  Writer.AddAPInt(T->getSize(), Record);
-  Code = pch::TYPE_CONSTANT_ARRAY_WITHOUT_EXPR;
-}
-
 void PCHTypeWriter::VisitIncompleteArrayType(const IncompleteArrayType *T) {
   VisitArrayType(T);
   Code = pch::TYPE_INCOMPLETE_ARRAY;
diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp
index ba05a07f265..9061576f813 100644
--- a/clang/lib/Sema/Sema.cpp
+++ b/clang/lib/Sema/Sema.cpp
@@ -361,9 +361,8 @@ void Sema::ActOnEndOfTranslationUnit() {
       // Set the length of the array to 1 (C99 6.9.2p5).
       Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
       llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
-      QualType T
-        = Context.getConstantArrayWithoutExprType(ArrayT->getElementType(),
-                                                  One, ArrayType::Normal, 0);
+      QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
+                                                One, ArrayType::Normal, 0);
       VD->setType(T);
     } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
                                    diag::err_tentative_def_incomplete_type))
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 606b33f5f74..fd96e95afc3 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -1903,16 +1903,9 @@ static QualType TryToFixInvalidVariablyModifiedType(QualType T,
 
   llvm::APSInt &Res = EvalResult.Val.getInt();
   if (Res >= llvm::APSInt(Res.getBitWidth(), Res.isUnsigned())) {
-    Expr* ArySizeExpr = VLATy->getSizeExpr();
-    // FIXME: here we could "steal" (how?) ArySizeExpr from the VLA,
-    // so as to transfer ownership to the ConstantArrayWithExpr.
-    // Alternatively, we could "clone" it (how?).
-    // Since we don't know how to do things above, we just use the
-    // very same Expr*.
-    return Context.getConstantArrayWithExprType(VLATy->getElementType(),
-                                                Res, ArySizeExpr,
-                                                ArrayType::Normal, 0,
-                                                VLATy->getBracketsRange());
+    // TODO: preserve the size expression in declarator info
+    return Context.getConstantArrayType(VLATy->getElementType(),
+                                        Res, ArrayType::Normal, 0);
   }
 
   SizeIsNegative = true;
diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp
index 27f08968076..4746a2597e5 100644
--- a/clang/lib/Sema/SemaInit.cpp
+++ b/clang/lib/Sema/SemaInit.cpp
@@ -109,9 +109,9 @@ static void CheckStringInit(Expr *Str, QualType &DeclT, Sema &S) {
     llvm::APSInt ConstVal(32);
     ConstVal = StrLength;
     // Return a new array type (C99 6.7.8p22).
-    DeclT = S.Context.getConstantArrayWithoutExprType(IAT->getElementType(),
-                                                      ConstVal,
-                                                      ArrayType::Normal, 0);
+    DeclT = S.Context.getConstantArrayType(IAT->getElementType(),
+                                           ConstVal,
+                                           ArrayType::Normal, 0);
     return;
   }
 
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 9603ca8a51c..99b2a51ce72 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -610,8 +610,7 @@ QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
           << ArraySize->getSourceRange();
       }
     }
-    T = Context.getConstantArrayWithExprType(T, ConstVal, ArraySize,
-                                             ASM, Quals, Brackets);
+    T = Context.getConstantArrayType(T, ConstVal, ASM, Quals);
   }
   // If this is not C99, extwarn about VLA's and C99 array size modifiers.
   if (!getLangOptions().C99) {
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index ec5c6676f5d..a3c9fa5628a 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -340,29 +340,6 @@ public:
                                     const llvm::APInt &Size,
                                     unsigned IndexTypeQuals);
 
-  /// \brief Build a new constant array type given the element type, size
-  /// modifier, (known) size of the array, size expression, and index type
-  /// qualifiers.
-  ///
-  /// By default, performs semantic analysis when building the array type.
-  /// Subclasses may override this routine to provide different behavior.
-  QualType RebuildConstantArrayWithExprType(QualType ElementType,
-                                            ArrayType::ArraySizeModifier SizeMod,
-                                            const llvm::APInt &Size,
-                                            Expr *SizeExpr,
-                                            unsigned IndexTypeQuals,
-                                            SourceRange BracketsRange);
-
-  /// \brief Build a new constant array type given the element type, size
-  /// modifier, (known) size of the array, and index type qualifiers.
-  ///
-  /// By default, performs semantic analysis when building the array type.
-  /// Subclasses may override this routine to provide different behavior.
-  QualType RebuildConstantArrayWithoutExprType(QualType ElementType,
-                                               ArrayType::ArraySizeModifier SizeMod,
-                                               const llvm::APInt &Size,
-                                               unsigned IndexTypeQuals);
-
   /// \brief Build a new incomplete array type given the element type, size
   /// modifier, and index type qualifiers.
   ///
@@ -2077,52 +2054,6 @@ TreeTransform<Derived>::TransformConstantArrayType(const ConstantArrayType *T) {
 }
 
 template<typename Derived>
-QualType
-TreeTransform<Derived>::TransformConstantArrayWithExprType(
-                                      const ConstantArrayWithExprType *T) {
-  QualType ElementType = getDerived().TransformType(T->getElementType());
-  if (ElementType.isNull())
-    return QualType();
-
-  // Array bounds are not potentially evaluated contexts
-  EnterExpressionEvaluationContext Unevaluated(SemaRef, Action::Unevaluated);
-
-  Sema::OwningExprResult Size = getDerived().TransformExpr(T->getSizeExpr());
-  if (Size.isInvalid())
-    return QualType();
-
-  if (!getDerived().AlwaysRebuild() &&
-      ElementType == T->getElementType() &&
-      Size.get() == T->getSizeExpr())
-    return QualType(T, 0);
-
-  return getDerived().RebuildConstantArrayWithExprType(ElementType,
-                                                       T->getSizeModifier(),
-                                                       T->getSize(),
-                                                       Size.takeAs<Expr>(),
-                                               T->getIndexTypeCVRQualifiers(),
-                                                       T->getBracketsRange());
-}
-
-template<typename Derived>
-QualType
-TreeTransform<Derived>::TransformConstantArrayWithoutExprType(
-                                      const ConstantArrayWithoutExprType *T) {
-  QualType ElementType = getDerived().TransformType(T->getElementType());
-  if (ElementType.isNull())
-    return QualType();
-
-  if (!getDerived().AlwaysRebuild() &&
-      ElementType == T->getElementType())
-    return QualType(T, 0);
-
-  return getDerived().RebuildConstantArrayWithoutExprType(ElementType,
-                                                       T->getSizeModifier(),
-                                                       T->getSize(),
-                                             T->getIndexTypeCVRQualifiers());
-}
-
-template<typename Derived>
 QualType TreeTransform<Derived>::TransformIncompleteArrayType(
                                               const IncompleteArrayType *T) {
   QualType ElementType = getDerived().TransformType(T->getElementType());
@@ -4549,29 +4480,6 @@ TreeTransform<Derived>::RebuildConstantArrayType(QualType ElementType,
 
 template<typename Derived>
 QualType
-TreeTransform<Derived>::RebuildConstantArrayWithExprType(QualType ElementType,
-                                          ArrayType::ArraySizeModifier SizeMod,
-                                                      const llvm::APInt &Size,
-                                                         Expr *SizeExpr,
-                                                      unsigned IndexTypeQuals,
-                                                    SourceRange BracketsRange) {
-  return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, SizeExpr,
-                                       IndexTypeQuals, BracketsRange);
-}
-
-template<typename Derived>
-QualType
-TreeTransform<Derived>::RebuildConstantArrayWithoutExprType(
-                                                        QualType ElementType,
-                                          ArrayType::ArraySizeModifier SizeMod,
-                                                       const llvm::APInt &Size,
-                                                     unsigned IndexTypeQuals) {
-  return getDerived().RebuildArrayType(ElementType, SizeMod, &Size, 0,
-                                       IndexTypeQuals, SourceRange());
-}
-
-template<typename Derived>
-QualType
 TreeTransform<Derived>::RebuildIncompleteArrayType(QualType ElementType,
                                           ArrayType::ArraySizeModifier SizeMod,
                                                  unsigned IndexTypeQuals) {