[AST] Preserve parameter names in TypeReprs of function types.

Also fixup 'test/SourceKit/CodeExpand/code-expand.swift' and use the syntax
for adding parameter names with an underscore for first name.

Author: akyrtzi

include/swift/AST/TypeRepr.h

@@ -580,32 +580,47 @@ class TupleTypeRepr : public TypeRepr {
   friend class TypeRepr;
 };
 
-/// \brief A named element of a tuple type.
+/// \brief A named element of a tuple type or a named parameter of a function
+/// type.
 /// \code
-///   (x: Foo = 0)
+///   (x: Foo)
+///   (_ x: Foo) -> ()
 /// \endcode
 class NamedTypeRepr : public TypeRepr {
   Identifier Id;
   TypeRepr *Ty;
   SourceLoc IdLoc;
+  SourceLoc UnderscoreLoc;
 
 public:
+  /// Used for a named element of a tuple type.
   NamedTypeRepr(Identifier Id, TypeRepr *Ty, SourceLoc IdLoc)
     : TypeRepr(TypeReprKind::Named), Id(Id), Ty(Ty), IdLoc(IdLoc) {
   }
+  /// Used for a named parameter of a function type.
+  NamedTypeRepr(Identifier Id, TypeRepr *Ty, SourceLoc IdLoc,
+                SourceLoc underscoreLoc)
+    : TypeRepr(TypeReprKind::Named), Id(Id), Ty(Ty), IdLoc(IdLoc),
+      UnderscoreLoc(underscoreLoc) {
+  }
 
   bool hasName() const { return !Id.empty(); }
   Identifier getName() const { return Id; }
   TypeRepr *getTypeRepr() const { return Ty; }
   SourceLoc getNameLoc() const { return IdLoc; }
+  SourceLoc getUnderscoreLoc() const { return UnderscoreLoc; }
+
+  bool isNamedParameter() const { return UnderscoreLoc.isValid(); }
 
   static bool classof(const TypeRepr *T) {
     return T->getKind() == TypeReprKind::Named;
   }
   static bool classof(const NamedTypeRepr *T) { return true; }
 
 private:
-  SourceLoc getStartLocImpl() const { return IdLoc; }
+  SourceLoc getStartLocImpl() const {
+    return UnderscoreLoc.isValid() ? UnderscoreLoc : IdLoc;
+  }
   SourceLoc getEndLocImpl() const { return Ty->getEndLoc(); }
   void printImpl(ASTPrinter &Printer, const PrintOptions &Opts) const;
   friend class TypeRepr;

lib/AST/TypeRepr.cpp

@@ -198,7 +198,7 @@ TypeRepr *CloneVisitor::visitTupleTypeRepr(TupleTypeRepr *T) {
 
 TypeRepr *CloneVisitor::visitNamedTypeRepr(NamedTypeRepr *T) {
   return new (Ctx) NamedTypeRepr(T->getName(), visit(T->getTypeRepr()),
-                                 T->getNameLoc());
+                                 T->getNameLoc(), T->getUnderscoreLoc());
 }
 
 TypeRepr *CloneVisitor::visitProtocolCompositionTypeRepr(
@@ -411,9 +411,19 @@ void TupleTypeRepr::printImpl(ASTPrinter &Printer,
 
 void NamedTypeRepr::printImpl(ASTPrinter &Printer,
                               const PrintOptions &Opts) const {
-  if (!Id.empty()) {
-    Printer.printName(Id, PrintNameContext::TupleElement);
+  if (isNamedParameter()) {
+    // Printing empty Identifier is same as printing '_'.
+    Printer.printName(Identifier(), PrintNameContext::FunctionParameterExternal);
+    if (!Id.empty()) {
+      Printer << " ";
+      Printer.printName(Id, PrintNameContext::FunctionParameterLocal);
+    }
     Printer << ": ";
+  } else {
+    if (!Id.empty()) {
+      Printer.printName(Id, PrintNameContext::TupleElement);
+      Printer << ": ";
+    }
   }
   printTypeRepr(Ty, Printer, Opts);
 }

lib/Parse/ParseType.cpp

@@ -711,6 +711,12 @@ ParserResult<TupleTypeRepr> Parser::parseTypeTupleBody() {
         else
           diag.fixItReplace(SourceRange(firstNameLoc), "_");
       }
+
+      if (firstNameLoc.isValid() || secondNameLoc.isValid()) {
+        // Form the named parameter type representation.
+        ElementsR[i] = new (Context) NamedTypeRepr(secondName, ElementsR[i],
+                                                   secondNameLoc, firstNameLoc);
+      }
     }
   }
 

lib/Sema/TypeCheckType.cpp

@@ -2427,13 +2427,17 @@ Type TypeResolver::resolveTupleType(TupleTypeRepr *repr,
     elementOptions |= TR_FunctionInput;
 
   for (auto tyR : repr->getElements()) {
-    if (NamedTypeRepr *namedTyR = dyn_cast<NamedTypeRepr>(tyR)) {
+    NamedTypeRepr *namedTyR = dyn_cast<NamedTypeRepr>(tyR);
+    if (namedTyR && !(options & TR_ImmediateFunctionInput)) {
       Type ty = resolveType(namedTyR->getTypeRepr(), elementOptions);
       if (!ty || ty->is<ErrorType>()) return ty;
 
       elements.push_back(TupleTypeElt(ty, namedTyR->getName()));
     } else {
-      Type ty = resolveType(tyR, elementOptions);
+      // FIXME: Preserve and serialize parameter names in function types, maybe
+      // with a new sugar type.
+      Type ty = resolveType(namedTyR ? namedTyR->getTypeRepr() : tyR,
+                            elementOptions);
       if (!ty || ty->is<ErrorType>()) return ty;
 
       elements.push_back(TupleTypeElt(ty));

test/SourceKit/CodeExpand/code-expand.swift

@@ -1,5 +1,3 @@
-// REQUIRES: se_0111_complete
-
 // RUN: %sourcekitd-test -req=expand-placeholder %s | FileCheck %s
 
 foo(x: <#T##() -> Void#>)
@@ -17,7 +15,7 @@ anArr.indexOfObjectPassingTest(<#T##predicate: ((AnyObject!, Int, UnsafePointer<
 // CHECK-NEXT: <#code#>
 // CHECK-NEXT: }
 
-anArr.indexOfObjectPassingTest(<#T##predicate: ((obj: AnyObject!, idx: Int, stop: UnsafePointer<ObjCBool>) -> Bool)?##((obj: AnyObject!, idx: Int, stop: UnsafePointer<ObjCBool>) -> Bool)?#>)
+anArr.indexOfObjectPassingTest(<#T##predicate: ((_ obj: AnyObject!, _ idx: Int, _ stop: UnsafePointer<ObjCBool>) -> Bool)?##((_ obj: AnyObject!, _ idx: Int, _ stop: UnsafePointer<ObjCBool>) -> Bool)?#>)
 // CHECK:      anArr.indexOfObjectPassingTest { (obj, idx, stop) -> Bool in
 // CHECK-NEXT: <#code#>
 // CHECK-NEXT: }