Eliminate the stored "size" field in ArrayTypeRepr since it is always null, saving a word. NFC.

We should also eliminate the isOldSyntax as well, and just do the
error recovery in the parser (there is no need to retain the sugar here
anymore), but I'll do that as a separate change since it could be behavior
changing.

Author: lattner

include/swift/AST/DiagnosticsCommon.def

@@ -73,8 +73,6 @@ ERROR(class_var_not_in_class,common,none,
 // FIXME: Used by both the parser and the type-checker.
 ERROR(func_decl_without_brace,decl_parsing,PointsToFirstBadToken,
       "expected '{' in body of function declaration", ())
-ERROR(unsupported_fixed_length_array,type_parsing,none,
-      "fixed-length arrays are not yet supported", ())
 
 ERROR(new_array_syntax,type_parsing,none,
       "array types are now written with the brackets around the element type",

include/swift/AST/DiagnosticsParse.def

@@ -598,6 +598,8 @@ ERROR(nonliteral_enum_case_raw_value,type_parsing,PointsToFirstBadToken,
       "raw value for enum case must be a literal", ())
 
 // Collection Types
+ERROR(unsupported_fixed_length_array,type_parsing,none,
+      "fixed-length arrays are not yet supported", ())
 ERROR(expected_expr_array_type,expr_parsing,PointsToFirstBadToken,
       "expected expression for size of array type", ())
 ERROR(expected_rbracket_array_type,type_parsing,PointsToFirstBadToken,

include/swift/AST/TypeRepr.h

@@ -394,21 +394,18 @@ class FunctionTypeRepr : public TypeRepr {
 class ArrayTypeRepr : public TypeRepr {
   // FIXME: Tail allocation. Use bits to determine whether Base/Size are
   // available.
-  TypeRepr *Base;
-  llvm::PointerIntPair<ExprHandle *, 1, bool> SizeAndOldSyntax;
+  llvm::PointerIntPair<TypeRepr *, 1, bool> BaseAndIsOldSyntax;
   SourceRange Brackets;
 
 public:
-  ArrayTypeRepr(TypeRepr *Base, ExprHandle *Size, SourceRange Brackets,
-                bool OldSyntax)
-    : TypeRepr(TypeReprKind::Array), Base(Base),
-      SizeAndOldSyntax(Size, OldSyntax), Brackets(Brackets) { }
+  ArrayTypeRepr(TypeRepr *Base, SourceRange Brackets, bool OldSyntax)
+    : TypeRepr(TypeReprKind::Array), BaseAndIsOldSyntax(Base, OldSyntax),
+      Brackets(Brackets) { }
 
-  TypeRepr *getBase() const { return Base; }
-  ExprHandle *getSize() const { return SizeAndOldSyntax.getPointer(); }
+  TypeRepr *getBase() const { return BaseAndIsOldSyntax.getPointer(); }
   SourceRange getBrackets() const { return Brackets; }
 
-  bool usesOldSyntax() const { return SizeAndOldSyntax.getInt(); }
+  bool usesOldSyntax() const { return BaseAndIsOldSyntax.getInt(); }
 
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::Array;
@@ -418,16 +415,16 @@ class ArrayTypeRepr : public TypeRepr {
 private:
   SourceLoc getStartLocImpl() const {
     if (usesOldSyntax())
-      return Base->getStartLoc();
+      return getBase()->getStartLoc();
 
     return Brackets.Start;
   }
   SourceLoc getEndLocImpl() const {
-    // This test is necessary because the type Int[4][2] is represented as
-    // ArrayTypeRepr(ArrayTypeRepr(Int, 2), 4), so the range needs to cover both
+    // This test is necessary because the type Int[][] is represented as
+    // ArrayTypeRepr(ArrayTypeRepr(Int)), so the range needs to cover both
     // sets of brackets.
-    if (usesOldSyntax() && isa<ArrayTypeRepr>(Base))
-      return Base->getEndLoc();
+    if (usesOldSyntax() && isa<ArrayTypeRepr>(getBase()))
+      return getBase()->getEndLoc();
     return Brackets.End;
   }
   void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;

lib/AST/ASTDumper.cpp

@@ -2314,10 +2314,6 @@ class PrintTypeRepr : public TypeReprVisitor<PrintTypeRepr> {
   void visitArrayTypeRepr(ArrayTypeRepr *T) {
     printCommon(T, "type_array") << '\n';
     printRec(T->getBase());
-    if (T->getSize()) {
-      OS << '\n';
-      printRec(T->getSize()->getExpr());
-    }
     OS << ')';
   }
 

lib/AST/TypeRepr.cpp

@@ -158,8 +158,8 @@ TypeRepr *CloneVisitor::visitFunctionTypeRepr(FunctionTypeRepr *T) {
 }
 
 TypeRepr *CloneVisitor::visitArrayTypeRepr(ArrayTypeRepr *T) {
-  return new (Ctx) ArrayTypeRepr(visit(T->getBase()), T->getSize(),
-                                 T->getBrackets(), T->usesOldSyntax());
+  return new (Ctx) ArrayTypeRepr(visit(T->getBase()), T->getBrackets(),
+                                 T->usesOldSyntax());
 }
 
 TypeRepr *CloneVisitor::visitDictionaryTypeRepr(DictionaryTypeRepr *T) {
@@ -339,14 +339,11 @@ void FunctionTypeRepr::printImpl(ASTPrinter &Printer,
 void ArrayTypeRepr::printImpl(ASTPrinter &Printer,
                               const PrintOptions &Opts) const {
   if (usesOldSyntax()) {
-    printTypeRepr(Base, Printer, Opts);
-    Printer << "[";
-    if (auto size = getSize())
-      size->getExpr()->print(Printer, Opts);
-    Printer << "]";
+    printTypeRepr(getBase(), Printer, Opts);
+    Printer << "[]";
   } else {
     Printer << "[";
-    printTypeRepr(Base, Printer, Opts);
+    printTypeRepr(getBase(), Printer, Opts);
     Printer << "]";
   }
 }

lib/Parse/ParseType.cpp

@@ -586,8 +586,8 @@ ParserResult<ArrayTypeRepr> Parser::parseTypeArray(TypeRepr *Base) {
     }
 
     // Just build a normal array slice type.
-    ATR = new (Context) ArrayTypeRepr(NestedType.get(), nullptr,
-                                           SourceRange(lsquareLoc, rsquareLoc),
+    ATR = new (Context) ArrayTypeRepr(NestedType.get(),
+                                      SourceRange(lsquareLoc, rsquareLoc),
                                       /*OldSyntax=*/true);
 
     if (NestedType.isParseError())
@@ -623,7 +623,6 @@ ParserResult<ArrayTypeRepr> Parser::parseTypeArray(TypeRepr *Base) {
     .highlight(sizeEx.get()->getSourceRange());
 
     ATR = new (Context) ArrayTypeRepr(NestedType.get(),
-                                      nullptr,
                                       SourceRange(lsquareLoc,
                                                   getEndOfPreviousLoc()),
                                       /*OldSyntax=*/true);
@@ -643,9 +642,8 @@ ParserResult<ArrayTypeRepr> Parser::parseTypeArray(TypeRepr *Base) {
 
   // Create an array slice type for the malformed array type specification
   NestedType = makeParserErrorResult(Base);
-  ATR = new (Context) ArrayTypeRepr(NestedType.get(), nullptr,
-                                    SourceRange(lsquareLoc,
-                                                PreviousLoc),
+  ATR = new (Context) ArrayTypeRepr(NestedType.get(),
+                                    SourceRange(lsquareLoc, PreviousLoc),
                                     /*OldSyntax=*/true);
   return makeParserErrorResult(ATR);
 }
@@ -693,7 +691,6 @@ ParserResult<TypeRepr> Parser::parseTypeCollection() {
   // Form the array type.
   return makeParserResult(firstTy,
                           new (Context) ArrayTypeRepr(firstTy.get(),
-                                                      nullptr,
                                                       brackets,
                                                       /*OldSyntax=*/false));
 }

lib/Sema/TypeCheckConstraints.cpp

@@ -861,8 +861,7 @@ TypeExpr *PreCheckExpression::simplifyTypeExpr(Expr *E) {
            "the TypeExpr should have been built correctly in the first place");
 
     auto *NewTypeRepr =
-      new (TC.Context) ArrayTypeRepr(InnerTypeRepr, nullptr,
-                                     Indexes->getSourceRange(),
+      new (TC.Context) ArrayTypeRepr(InnerTypeRepr, Indexes->getSourceRange(),
                                      /*OldSyntax=*/true);
 
     TC.diagnose(Indexes->getStartLoc(), diag::new_array_syntax)
@@ -997,7 +996,7 @@ TypeExpr *PreCheckExpression::simplifyTypeExpr(Expr *E) {
       return nullptr;
 
     auto *NewTypeRepr =
-      new (TC.Context) ArrayTypeRepr(TyExpr->getTypeRepr(), nullptr,
+      new (TC.Context) ArrayTypeRepr(TyExpr->getTypeRepr(), 
                                      SourceRange(AE->getLBracketLoc(),
                                                  AE->getRBracketLoc()),
                                      /*OldSyntax=*/false);

lib/Sema/TypeCheckType.cpp

@@ -2097,12 +2097,6 @@ Type TypeResolver::resolveArrayType(ArrayTypeRepr *repr,
   // FIXME: diagnose non-materializability of element type!
   Type baseTy = resolveType(repr->getBase(), withoutContext(options));
   if (!baseTy || baseTy->is<ErrorType>()) return baseTy;
-  
-  if (ExprHandle *sizeEx = repr->getSize()) {
-    TC.diagnose(repr->getBrackets().Start, diag::unsupported_fixed_length_array)
-      .highlight(sizeEx->getExpr()->getSourceRange());
-    return ErrorType::get(Context);
-  }
 
   auto sliceTy = TC.getArraySliceType(repr->getBrackets().Start, baseTy);
   if (!sliceTy)