remove & dial back three old bits of syntax auto-upgrading support:

1. Array type parsing for postfix array types Int[].  We now handle this
   in the parser, but remove the AST representation of this old form.  We
   also stop making vague promises about the future by saying that "fixed
   size arrays aren't supported... yet".  Removal of this fixes a compiler
   crasher too.

2. Remove the special case support for migrating @autoclosure from types
   to parameters, which was Swift 1.0/1.1 syntax.  The world has moved or
   we don't care anymore.

3. Remove upgrade support for # arguments (nee "backtick" arguments), which
   was a Swift 1.x'ism abolished in an effort to simplify method naming
   rules.

NFC on valid code.

Author: lattner

include/swift/AST/DiagnosticsCommon.def

@@ -74,10 +74,6 @@ ERROR(class_var_not_in_class,common,none,
 ERROR(func_decl_without_brace,decl_parsing,PointsToFirstBadToken,
       "expected '{' in body of function declaration", ())
 
-ERROR(new_array_syntax,type_parsing,none,
-      "array types are now written with the brackets around the element type",
-      ())
-
 NOTE(convert_let_to_var,sema,none,
      "change 'let' to 'var' to make it mutable", ())
 NOTE(change_let_to_var_param,sema,none,

include/swift/AST/DiagnosticsParse.def

@@ -188,8 +188,6 @@ ERROR(decl_already_static,decl_parsing,none,
 ERROR(autoclosure_is_decl_attribute,attribute_parsing,none,
       "@autoclosure is now an attribute of the parameter "
       "declaration, not its type", ())
-ERROR(autoclosure_not_on_enums,attribute_parsing,none,
-      "@autoclosure is only allowed on parameters, not on enum cases", ())
 
 ERROR(enum_case_dot_prefix,decl_parsing,none,
       "extraneous '.' in enum 'case' declaration", ())
@@ -598,10 +596,9 @@ 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(new_array_syntax,type_parsing,none,
+      "array types are now written with the brackets around the element type",
+      ())
 ERROR(expected_rbracket_array_type,type_parsing,PointsToFirstBadToken,
       "expected ']' in array type", ())
 ERROR(expected_element_type,type_parsing,PointsToFirstBadToken,
@@ -662,26 +659,13 @@ ERROR(multiple_parameter_ellipsis,decl_parsing,none,
       "only a single variadic parameter '...' is permitted", ())
 ERROR(parameter_vararg_default,decl_parsing,none,
       "variadic parameter cannot have a default value", ())
-ERROR(parameter_backtick_missing_name,decl_parsing,PointsToFirstBadToken,
-      "expected parameter name after '#'", ())
-ERROR(parameter_backtick_empty_name,decl_parsing,none,
-      "expected non-empty parameter name after '#'", ())
 ERROR(parameter_inout_var_let,decl_parsing,none,
       "parameter may not have multiple 'inout', 'var', or 'let' specifiers",
       ())
 
-WARNING(parameter_backtick_two_names,decl_parsing,none,
-      "extraneous '#' in parameter; keyword argument and parameter name "
-      "already specified separately", ())
 WARNING(parameter_extraneous_double_up,decl_parsing,none,
         "extraneous duplicate parameter name; %0 already has an argument "
         "label", (Identifier))
-ERROR(parameter_extraneous_pound,decl_parsing,none,
-        "'#' has been removed from Swift; %0 already has an argument label",
-        (Identifier))
-ERROR(parameter_pound_double_up,decl_parsing,none,
-        "'#' has been removed from Swift; double up '%0 %0' to make the "
-        "argument label the same as the parameter name", (StringRef))
 WARNING(parameter_extraneous_empty_name,decl_parsing,none,
         "extraneous '_' in parameter: %0 has no keyword argument name",
         (Identifier))

include/swift/AST/DiagnosticsSema.def

@@ -2052,12 +2052,6 @@ ERROR(type_pattern_missing_is,sema_tcp,none,
 
 ERROR(pattern_type_mismatch_context,sema_tcp,none,
       "type annotation does not match contextual type %0", (Type))
-ERROR(label_single_entry_tuple,sema_tcp,none,
-      "label is not allowed on single element tuple pattern", ())
-NOTE(remove_parens_for_type_annotation,sema_tcp,none,
-     "remove the parentheses to make this a type annotation", ())
-NOTE(remove_label_for_tuple_pattern,sema_tcp,none,
-     "remove the label to make this a tuple pattern", ())
 
 ERROR(tuple_pattern_in_non_tuple_context,sema_tcp,none,
       "tuple pattern cannot match values of the non-tuple type %0", (Type))

include/swift/AST/TypeRepr.h

@@ -392,41 +392,24 @@ class FunctionTypeRepr : public TypeRepr {
 ///   [Foo]
 /// \endcode
 class ArrayTypeRepr : public TypeRepr {
-  // FIXME: Tail allocation. Use bits to determine whether Base/Size are
-  // available.
-  llvm::PointerIntPair<TypeRepr *, 1, bool> BaseAndIsOldSyntax;
+  TypeRepr *Base;
   SourceRange Brackets;
 
 public:
-  ArrayTypeRepr(TypeRepr *Base, SourceRange Brackets, bool OldSyntax)
-    : TypeRepr(TypeReprKind::Array), BaseAndIsOldSyntax(Base, OldSyntax),
-      Brackets(Brackets) { }
+  ArrayTypeRepr(TypeRepr *Base, SourceRange Brackets)
+    : TypeRepr(TypeReprKind::Array), Base(Base), Brackets(Brackets) { }
 
-  TypeRepr *getBase() const { return BaseAndIsOldSyntax.getPointer(); }
+  TypeRepr *getBase() const { return Base; }
   SourceRange getBrackets() const { return Brackets; }
 
-  bool usesOldSyntax() const { return BaseAndIsOldSyntax.getInt(); }
-
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::Array;
   }
   static bool classof(const ArrayTypeRepr *T) { return true; }
 
 private:
-  SourceLoc getStartLocImpl() const {
-    if (usesOldSyntax())
-      return getBase()->getStartLoc();
-
-    return Brackets.Start;
-  }
-  SourceLoc getEndLocImpl() const {
-    // 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>(getBase()))
-      return getBase()->getEndLoc();
-    return Brackets.End;
-  }
+  SourceLoc getStartLocImpl() const { return Brackets.Start; }
+  SourceLoc getEndLocImpl() const { return Brackets.End; }
   void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
   friend class TypeRepr;
 };
@@ -778,10 +761,8 @@ inline bool TypeRepr::isSimple() const {
   case TypeReprKind::ProtocolComposition:
   case TypeReprKind::Tuple:
   case TypeReprKind::Fixed:
-    return true;
-
   case TypeReprKind::Array:
-    return !cast<ArrayTypeRepr>(this)->usesOldSyntax();
+    return true;
   }
   llvm_unreachable("bad TypeRepr kind");
 }

include/swift/Parse/Parser.h

@@ -860,7 +860,7 @@ class Parser {
 
   ParserResult<ProtocolCompositionTypeRepr> parseTypeComposition();
   ParserResult<TupleTypeRepr> parseTypeTupleBody();
-  ParserResult<ArrayTypeRepr> parseTypeArray(TypeRepr *Base);
+  ParserResult<TypeRepr> parseTypeArray(TypeRepr *Base);
 
   /// Parse a collection type.
   ///   type-simple:
@@ -923,10 +923,6 @@ class Parser {
     };
     SpecifierKindTy SpecifierKind = Let; // Defaults to let.
 
-    
-    /// The location of the back-tick preceding the first name, if any.
-    SourceLoc PoundLoc;
-
     /// The location of the first name.
     ///
     /// \c FirstName is the name.

lib/AST/TypeRepr.cpp

@@ -158,8 +158,7 @@ TypeRepr *CloneVisitor::visitFunctionTypeRepr(FunctionTypeRepr *T) {
 }
 
 TypeRepr *CloneVisitor::visitArrayTypeRepr(ArrayTypeRepr *T) {
-  return new (Ctx) ArrayTypeRepr(visit(T->getBase()), T->getBrackets(),
-                                 T->usesOldSyntax());
+  return new (Ctx) ArrayTypeRepr(visit(T->getBase()), T->getBrackets());
 }
 
 TypeRepr *CloneVisitor::visitDictionaryTypeRepr(DictionaryTypeRepr *T) {
@@ -338,14 +337,9 @@ void FunctionTypeRepr::printImpl(ASTPrinter &Printer,
 
 void ArrayTypeRepr::printImpl(ASTPrinter &Printer,
                               const PrintOptions &Opts) const {
-  if (usesOldSyntax()) {
-    printTypeRepr(getBase(), Printer, Opts);
-    Printer << "[]";
-  } else {
-    Printer << "[";
-    printTypeRepr(getBase(), Printer, Opts);
-    Printer << "]";
-  }
+  Printer << "[";
+  printTypeRepr(getBase(), Printer, Opts);
+  Printer << "]";
 }
 
 void DictionaryTypeRepr::printImpl(ASTPrinter &Printer,

lib/Parse/ParseDecl.cpp

@@ -1440,40 +1440,26 @@ bool Parser::parseTypeAttribute(TypeAttributes &Attributes, bool justChecking) {
       // Otherwise this is a valid decl attribute so they should have put it on
       // the decl instead of the type.
 
-      auto diagID = diag::decl_attribute_applied_to_type;
-      if (declAttrID == DAK_AutoClosure) {
-        // Special case handling of @autoclosure attribute on the type, which
-        // was supported in Swift 1.0 and 1.1, but removed in Swift 1.2.
-        diagID = diag::autoclosure_is_decl_attribute;
-
-        // Further special case handling of @autoclosure attribute in
-        // enumerators in EnumDecl's to produce a nice diagnostic.
-        if (CurDeclContext && isa<EnumDecl>(CurDeclContext))
-          diagID = diag::autoclosure_not_on_enums;
-      }
-
       // If this is the first attribute, and if we are on a simple decl, emit a
       // fixit to move the attribute.  Otherwise, we don't have the location of
       // the @ sign, or we don't have confidence that the fixit will be right.
       if (!Attributes.empty() || StructureMarkers.empty() ||
           StructureMarkers.back().Kind != StructureMarkerKind::Declaration ||
           StructureMarkers.back().Loc.isInvalid() ||
           peekToken().is(tok::equal)) {
-        diagnose(Tok, diagID);
+        diagnose(Tok, diag::decl_attribute_applied_to_type);
       } else {
         // Otherwise, this is the first type attribute and we know where the
         // declaration is.  Emit the same diagnostic, but include a fixit to
         // move the attribute.  Unfortunately, we don't have enough info to add
         // the attribute to DeclAttributes.
-        diagnose(Tok, diagID)
+        diagnose(Tok, diag::decl_attribute_applied_to_type)
           .fixItRemove(SourceRange(Attributes.AtLoc, Tok.getLoc()))
           .fixItInsert(StructureMarkers.back().Loc,
                        "@" + Tok.getText().str()+" ");
       }
     }
 
-    
-
     // Recover by eating @foo when foo is not known.
     consumeToken();
 

lib/Parse/ParsePattern.cpp

@@ -199,38 +199,14 @@ Parser::parseParameterClause(SourceLoc &leftParenLoc,
       consumeToken();
     }
 
-    // '#'?
-    if (Tok.is(tok::pound))
-      param.PoundLoc = consumeToken(tok::pound);
-
-    if (param.PoundLoc.isValid() || startsParameterName(*this, isClosure)) {
+    if (startsParameterName(*this, isClosure)) {
       // identifier-or-none for the first name
       if (Tok.is(tok::kw__)) {
-        // A back-tick cannot precede an empty name marker.
-        if (param.PoundLoc.isValid()) {
-          diagnose(Tok, diag::parameter_backtick_empty_name)
-          .fixItRemove(param.PoundLoc);
-          param.PoundLoc = SourceLoc();
-        }
-
         param.FirstNameLoc = consumeToken();
-      } else if (Tok.canBeArgumentLabel()) {
+      } else {
+        assert(Tok.canBeArgumentLabel() && "startsParameterName() lied");
         param.FirstName = Context.getIdentifier(Tok.getText());
         param.FirstNameLoc = consumeToken();
-
-        // Operators cannot have API names.
-        if (paramContext == ParameterContextKind::Operator &&
-            param.PoundLoc.isValid()) {
-          diagnose(param.PoundLoc, 
-                   diag::parameter_operator_keyword_argument)
-            .fixItRemove(param.PoundLoc);
-          param.PoundLoc = SourceLoc();
-        }
-      } else {
-        assert(param.PoundLoc.isValid() && "startsParameterName() lied");
-        diagnose(Tok, diag::parameter_backtick_missing_name);
-        param.FirstNameLoc = param.PoundLoc;
-        param.PoundLoc = SourceLoc();
       }
 
       // identifier-or-none? for the second name
@@ -254,31 +230,10 @@ Parser::parseParameterClause(SourceLoc &leftParenLoc,
         param.SecondNameLoc = SourceLoc();
       }
 
-      // Cannot have a pound and two names.
-      if (param.PoundLoc.isValid() && param.SecondNameLoc.isValid()) {
-        diagnose(param.PoundLoc, diag::parameter_backtick_two_names)
-          .fixItRemove(param.PoundLoc);
-        param.PoundLoc = SourceLoc();
-      }
-
       // (':' type)?
       if (Tok.is(tok::colon)) {
         param.ColonLoc = consumeToken();
 
-        // Special case handling of @autoclosure attribute on the type, which
-        // was supported in Swift 1.0 and 1.1, but removed in Swift 1.2 (moved
-        // to a decl attribute).
-        if (Tok.is(tok::at_sign) &&
-            peekToken().isContextualKeyword("autoclosure")) {
-          SourceLoc AtLoc = consumeToken(tok::at_sign);
-          SourceLoc ACLoc = consumeToken(tok::identifier);
-          diagnose(AtLoc, diag::autoclosure_is_decl_attribute)
-            .fixItRemove(SourceRange(AtLoc, ACLoc))
-            .fixItInsert(StartLoc, "@autoclosure ");
-          param.Attrs.add(new (Context) AutoClosureAttr(AtLoc, ACLoc,
-                                                        /*escaping=*/false));
-        }
-
         auto type = parseType(diag::expected_parameter_type);
         status |= type;
         param.Type = type.getPtrOrNull();
@@ -447,25 +402,8 @@ mapParsedParameters(Parser &parser,
           .fixItRemoveChars(param.FirstNameLoc, param.SecondNameLoc);
       }
     } else {
-      // If it's an API name by default, or there was a pound, we have an
-      // API name.
-      if (isKeywordArgumentByDefault || param.PoundLoc.isValid()) {
+      if (isKeywordArgumentByDefault)
         argName = param.FirstName;
-
-        // The pound is going away. Complain.
-        if (param.PoundLoc.isValid()) {
-          if (isKeywordArgumentByDefault) {
-            parser.diagnose(param.PoundLoc, diag::parameter_extraneous_pound,
-                            argName)
-              .fixItRemove(param.PoundLoc);
-          } else {
-            parser.diagnose(param.PoundLoc, diag::parameter_pound_double_up,
-                            argName.str())
-              .fixItReplace(param.PoundLoc, (argName.str() + " ").str());
-          }
-        }
-      }
-
       paramName = param.FirstName;
 
       result = createParamPattern(param.LetVarInOutLoc, param.SpecifierKind,