Implement SE-0066 - Standardize function type argument syntax to require parentheses

For now, we'll keep this as a warning to allow projects to adapt.

Author: lattner

include/swift/AST/DiagnosticsSema.def

@@ -2574,6 +2574,8 @@ ERROR(objc_invalid_with_generic_params,none,
 ERROR(objc_convention_invalid,none,
       "%0 is not representable in Objective-C, so it cannot be used"
       " with '@convention(%1)'", (Type, StringRef))
+WARNING(function_type_no_parens,none,
+        "single argument function types require parentheses", ())
 NOTE(not_objc_empty_protocol_composition,none,
      "'protocol<>' is not considered '@objc'; use 'AnyObject' instead", ())
 NOTE(not_objc_protocol,none,

include/swift/AST/TypeRepr.h

@@ -46,16 +46,22 @@ class alignas(8) TypeRepr {
   void operator=(const TypeRepr&) = delete;
 
   /// \brief The subclass of TypeRepr that this is.
-  unsigned Kind : 7;
+  unsigned Kind : 6;
 
   /// Whether this type representation is known to contain an invalid
   /// type.
   unsigned Invalid : 1;
 
+  /// Whether this type representation had a warning emitted related to it.
+  /// This is a hack related to how we resolve type exprs multiple times in
+  /// generic contexts.
+  unsigned Warned : 1;
+
   SourceLoc getLocImpl() const { return getStartLoc(); }
 
 protected:
-  TypeRepr(TypeReprKind K) : Kind(static_cast<unsigned>(K)), Invalid(false) {}
+  TypeRepr(TypeReprKind K)
+    : Kind(static_cast<unsigned>(K)), Invalid(false), Warned(false) {}
 
 public:
   TypeReprKind getKind() const { return static_cast<TypeReprKind>(Kind); }
@@ -66,6 +72,11 @@ class alignas(8) TypeRepr {
   /// Note that this type representation describes an invalid type.
   void setInvalid() { Invalid = true; }
 
+  /// If a warning is produced about this type repr, keep track of that so we
+  /// don't emit another one upon further reanalysis.
+  bool isWarnedAbout() const { return Warned; }
+  void setWarned() { Warned = true; }
+  
   /// Get the representative location for pointing at this type.
   SourceLoc getLoc() const;
 

lib/Sema/TypeCheckType.cpp

@@ -1341,10 +1341,11 @@ Type TypeChecker::resolveIdentifierType(
   return result;
 }
 
-// Returns true if any illegal IUOs were found. If inference of IUO type is disabled, IUOs may only be specified in the following positions:
-//  * outermost type
-//  * function param
-//  * function return type
+/// Returns true if any illegal IUOs were found. If inference of IUO type is
+/// disabled, IUOs may only be specified in the following positions:
+///  * outermost type
+///  * function param
+///  * function return type
 static bool checkForIllegalIUOs(TypeChecker &TC, TypeRepr *Repr,
                                 TypeResolutionOptions Options) {
   class IllegalIUOWalker : public ASTWalker {
@@ -1889,6 +1890,20 @@ Type TypeResolver::resolveASTFunctionType(FunctionTypeRepr *repr,
   extInfo = extInfo.withThrows(repr->throws());
 
   ModuleDecl *M = DC->getParentModule();
+  
+  
+  // If this is a function type without parens around the parameter list,
+  // diagnose this and produce a fixit to add them.
+  if (!isa<TupleTypeRepr>(repr->getArgsTypeRepr()) &&
+      !repr->isWarnedAbout()) {
+    auto args = repr->getArgsTypeRepr();
+    TC.diagnose(args->getStartLoc(), diag::function_type_no_parens)
+      .highlight(args->getSourceRange())
+      .fixItInsert(args->getStartLoc(), "(")
+    .fixItInsertAfter(args->getEndLoc(), ")");
+    // Don't emit this warning three times when in generics.
+    repr->setWarned();
+  }
 
   // SIL uses polymorphic function types to resolve overloaded member functions.
   if (auto genericParams = repr->getGenericParams()) {

test/type/types.swift

@@ -155,3 +155,8 @@ class r21949448 {
   var myArray: inout [Int] = []   // expected-error {{'inout' is only valid in parameter lists}}
 }
 
+// SE-0066 - Standardize function type argument syntax to require parentheses
+let _ : Int -> Float // expected-warning {{single argument function types require parentheses}} {{9-9=(}} {{12-12=)}}
+
+
+