[SE-0111] Drop argument labels on references to function values.

When referencing a function in the type checker, drop argument labels
when we don't need them to type-check an immediate call to that
function. This provides the semantic behavior of SE-0111, e.g.,
references to functions as values produce unlabeled function types,
without the representational change of actually dropping argument
labels from the type system.

At the moment, this only works for bare references to functions. It
still needs to be pushed through more of the type checker and more AST
nodes to work in the general case.

Keep this work behind the frontend flag
-suppress-argument-labels-in-types for now.

Author: DougGregor

include/swift/AST/DeclNameLoc.h

@@ -78,6 +78,9 @@ class DeclNameLoc {
   /// Whether the location information is invalid.
   bool isInvalid() const { return getBaseNameLoc().isInvalid(); }
 
+  /// Whether this was written as a compound name.
+  bool isCompound() const { return NumArgumentLabels > 0; }
+
   /// Retrieve the location of the base name.
   SourceLoc getBaseNameLoc() const {
     return getSourceLocs()[BaseNameIndex];

include/swift/AST/Expr.h

@@ -20,6 +20,7 @@
 #include "swift/AST/CaptureInfo.h"
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/DeclNameLoc.h"
+#include "swift/AST/FunctionRefKind.h"
 #include "swift/AST/ProtocolConformanceRef.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/AST/TypeLoc.h"
@@ -53,7 +54,7 @@ namespace swift {
   class PatternBindingDecl;
   class ParameterList;
   class EnumElementDecl;
-  
+
 enum class ExprKind : uint8_t {
 #define EXPR(Id, Parent) Id,
 #define EXPR_RANGE(Id, FirstId, LastId) \
@@ -114,7 +115,7 @@ enum class AccessSemantics : unsigned char {
   /// polymorphism is expected.
   Ordinary,
 };
-  
+
 /// Expr - Base class for all expressions in swift.
 class alignas(8) Expr {
   Expr(const Expr&) = delete;
@@ -164,10 +165,21 @@ class alignas(8) Expr {
     friend class DeclRefExpr;
     unsigned : NumExprBits;
     unsigned Semantics : 2; // an AccessSemantics
+    unsigned FunctionRefKind : 2;
   };
-  enum { NumDeclRefExprBits = NumExprBits + 2 };
+  enum { NumDeclRefExprBits = NumExprBits + 4 };
   static_assert(NumDeclRefExprBits <= 32, "fits in an unsigned");
 
+  class UnresolvedDeclRefExprBitfields {
+    friend class UnresolvedDeclRefExpr;
+    unsigned : NumExprBits;
+    unsigned DeclRefKind : 2;
+    unsigned IsSpecialized : 1;
+    unsigned FunctionRefKind : 2;
+  };
+  enum { NumUnresolvedDeclRefExprBits = NumExprBits + 5 };
+  static_assert(NumUnresolvedDeclRefExprBits <= 32, "fits in an unsigned");
+
   class MemberRefExprBitfields {
     friend class MemberRefExpr;
     unsigned : NumExprBits;
@@ -246,6 +258,15 @@ class alignas(8) Expr {
   enum { NumOverloadSetRefExprBits = NumExprBits };
   static_assert(NumOverloadSetRefExprBits <= 32, "fits in an unsigned");
 
+  class OverloadedDeclRefExprBitfields {
+    friend class OverloadedDeclRefExpr;
+    unsigned : NumOverloadSetRefExprBits;
+    unsigned IsSpecialized : 1;
+    unsigned FunctionRefKind : 2;
+  };
+  enum { NumOverloadedDeclRefExprBits = NumOverloadSetRefExprBits + 3 };
+  static_assert(NumOverloadedDeclRefExprBits <= 32, "fits in an unsigned");
+
   class BooleanLiteralExprBitfields {
     friend class BooleanLiteralExpr;
     unsigned : NumLiteralExprBits;
@@ -398,12 +419,14 @@ class alignas(8) Expr {
     NumberLiteralExprBitfields NumberLiteralExprBits;
     StringLiteralExprBitfields StringLiteralExprBits;
     DeclRefExprBitfields DeclRefExprBits;
+    UnresolvedDeclRefExprBitfields UnresolvedDeclRefExprBits;
     TupleExprBitfields TupleExprBits;
     MemberRefExprBitfields MemberRefExprBits;
     SubscriptExprBitfields SubscriptExprBits;
     DynamicSubscriptExprBitfields DynamicSubscriptExprBits;
     UnresolvedMemberExprBitfields UnresolvedMemberExprBits;
     OverloadSetRefExprBitfields OverloadSetRefExprBits;
+    OverloadedDeclRefExprBitfields OverloadedDeclRefExprBits;
     BooleanLiteralExprBitfields BooleanLiteralExprBits;
     MagicIdentifierLiteralExprBitfields MagicIdentifierLiteralExprBits;
     ObjectLiteralExprBitfields ObjectLiteralExprBits;
@@ -1212,6 +1235,9 @@ class DeclRefExpr : public Expr {
               Type Ty = Type())
     : Expr(ExprKind::DeclRef, Implicit, Ty), DOrSpecialized(D), Loc(Loc) {
     DeclRefExprBits.Semantics = (unsigned) semantics;
+    DeclRefExprBits.FunctionRefKind =
+      static_cast<unsigned>(Loc.isCompound() ? FunctionRefKind::Compound
+                                             : FunctionRefKind::Unapplied);
   }
 
   /// Retrieve the declaration to which this expression refers.
@@ -1254,6 +1280,16 @@ class DeclRefExpr : public Expr {
   SourceLoc getLoc() const { return Loc.getBaseNameLoc(); }
   DeclNameLoc getNameLoc() const { return Loc; }
 
+  /// Retrieve the kind of function reference.
+  FunctionRefKind getFunctionRefKind() const {
+    return static_cast<FunctionRefKind>(DeclRefExprBits.FunctionRefKind);
+  }
+
+  /// Set the kind of function reference.
+  void setFunctionRefKind(FunctionRefKind refKind) {
+    DeclRefExprBits.FunctionRefKind = static_cast<unsigned>(refKind);
+  }
+
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::DeclRef;
   }
@@ -1388,26 +1424,42 @@ class OverloadSetRefExpr : public Expr {
 
 /// OverloadedDeclRefExpr - A reference to an overloaded name that should
 /// eventually be resolved (by overload resolution) to a value reference.
-class OverloadedDeclRefExpr : public OverloadSetRefExpr {
+class OverloadedDeclRefExpr final : public OverloadSetRefExpr {
   DeclNameLoc Loc;
-  bool IsSpecialized = false;
 
 public:
   OverloadedDeclRefExpr(ArrayRef<ValueDecl*> Decls, DeclNameLoc Loc,
+                        bool isSpecialized,
+                        FunctionRefKind functionRefKind,
                         bool Implicit, Type Ty = Type())
-    : OverloadSetRefExpr(ExprKind::OverloadedDeclRef, Decls, Implicit, Ty),
-      Loc(Loc) { }
+      : OverloadSetRefExpr(ExprKind::OverloadedDeclRef, Decls, Implicit, Ty),
+        Loc(Loc) {
+    OverloadedDeclRefExprBits.IsSpecialized = isSpecialized;
+    OverloadedDeclRefExprBits.FunctionRefKind =
+      static_cast<unsigned>(functionRefKind);
+  }
 
   DeclNameLoc getNameLoc() const { return Loc; }
   SourceLoc getLoc() const { return Loc.getBaseNameLoc(); }
   SourceRange getSourceRange() const { return Loc.getSourceRange(); }
 
-  void setSpecialized(bool specialized) { IsSpecialized = specialized; }
-
   /// \brief Determine whether this declaration reference was immediately
   /// specialized by <...>.
-  bool isSpecialized() const { return IsSpecialized; }
-  
+  bool isSpecialized() const {
+    return OverloadedDeclRefExprBits.IsSpecialized;
+  }
+
+  /// Retrieve the kind of function reference.
+  FunctionRefKind getFunctionRefKind() const {
+    return static_cast<FunctionRefKind>(
+             OverloadedDeclRefExprBits.FunctionRefKind);
+  }
+
+  /// Set the kind of function reference.
+  void setFunctionRefKind(FunctionRefKind refKind) {
+    OverloadedDeclRefExprBits.FunctionRefKind = static_cast<unsigned>(refKind);
+  }
+
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::OverloadedDeclRef;
   }
@@ -1421,29 +1473,48 @@ class OverloadedDeclRefExpr : public OverloadSetRefExpr {
 class UnresolvedDeclRefExpr : public Expr {
   DeclName Name;
   DeclNameLoc Loc;
-  DeclRefKind RefKind;
-  bool IsSpecialized = false;
 
 public:
   UnresolvedDeclRefExpr(DeclName name, DeclRefKind refKind, DeclNameLoc loc)
-    : Expr(ExprKind::UnresolvedDeclRef, /*Implicit=*/loc.isInvalid()),
-      Name(name), Loc(loc), RefKind(refKind) {
+      : Expr(ExprKind::UnresolvedDeclRef, /*Implicit=*/loc.isInvalid()),
+        Name(name), Loc(loc) {
+    UnresolvedDeclRefExprBits.DeclRefKind = static_cast<unsigned>(refKind);
+    UnresolvedDeclRefExprBits.IsSpecialized = false;
+    UnresolvedDeclRefExprBits.FunctionRefKind =
+      static_cast<unsigned>(Loc.isCompound() ? FunctionRefKind::Compound
+                                             : FunctionRefKind::Unapplied);
   }
 
   bool hasName() const { return static_cast<bool>(Name); }
   DeclName getName() const { return Name; }
-  DeclRefKind getRefKind() const { return RefKind; }
 
-  void setSpecialized(bool specialized) { IsSpecialized = specialized; }
+  DeclRefKind getRefKind() const {
+    return static_cast<DeclRefKind>(UnresolvedDeclRefExprBits.DeclRefKind);
+  }
+
+  void setSpecialized(bool specialized) {
+    UnresolvedDeclRefExprBits.IsSpecialized = specialized;
+  }
 
   /// \brief Determine whether this declaration reference was immediately
   /// specialized by <...>.
-  bool isSpecialized() const { return IsSpecialized; }
+  bool isSpecialized() const { return UnresolvedDeclRefExprBits.IsSpecialized; }
+
+  /// Retrieve the kind of function reference.
+  FunctionRefKind getFunctionRefKind() const {
+    return static_cast<FunctionRefKind>(
+             UnresolvedDeclRefExprBits.FunctionRefKind);
+  }
+
+  /// Set the kind of function reference.
+  void setFunctionRefKind(FunctionRefKind refKind) {
+    UnresolvedDeclRefExprBits.FunctionRefKind = static_cast<unsigned>(refKind);
+  }
 
   DeclNameLoc getNameLoc() const { return Loc; }
 
   SourceRange getSourceRange() const { return Loc.getSourceRange(); }
-  
+
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::UnresolvedDeclRef;
   }

include/swift/AST/FunctionRefKind.h

@@ -0,0 +1,50 @@
+//===--- FunctionRefKind.h - Function reference kind ------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the FunctionRefKind enum, which is used to describe how
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_FUNCTION_REF_KIND_H
+#define SWIFT_AST_FUNCTION_REF_KIND_H
+
+namespace swift {
+
+/// Describes how a function is referenced within an expression node,
+/// which dictates whether argument labels are part of the resulting
+/// function type or not.
+///
+/// How a function is referenced comes down to how it was spelled in
+/// the source code, e.g., was it called in the source code and was it
+/// spelled as a compound name.
+enum class FunctionRefKind : unsigned {
+  /// The function was referenced using a bare function name (e.g.,
+  /// 'f') and not directly called.
+  Unapplied,
+  /// The function was referenced using a bare function name and was
+  /// directly applied once, e.g., "f(a: 1, b: 2)".
+  SingleApply,
+  /// The function was referenced using a bare function name and was
+  /// directly applied two or more times, e.g., "g(x)(y)".
+  DoubleApply,
+  /// The function was referenced using a compound function name,
+  /// e.g., "f(a:b:)".
+  Compound,
+};
+
+/// Produce a string describing a function reference kind, for
+/// debugging purposes.
+StringRef getFunctionRefKindStr(FunctionRefKind refKind);
+
+}
+
+#endif // SWIFT_AST_FUNCTION_REF_KIND_H

include/swift/Basic/LangOptions.h

@@ -95,6 +95,9 @@ namespace swift {
     /// was not compiled with -enable-testing.
     bool EnableTestableAttrRequiresTestableModule = true;
 
+    /// Whether to implement SE-0111, the removal of argument labels in types.
+    bool SuppressArgumentLabelsInTypes = false;
+
     ///
     /// Flags for developers
     ///

include/swift/Option/FrontendOptions.td

@@ -94,6 +94,10 @@ def disable_testable_attr_requires_testable_module :
   Flag<["-"], "disable-testable-attr-requires-testable-module">,
   HelpText<"Disable checking of @testable">;
 
+def suppress_argument_labels_in_types :
+  Flag<["-"], "suppress-argument-labels-in-types">,
+  HelpText<"SE-0111: Suppress argument labels in types">;
+
 def enable_target_os_checking :
   Flag<["-"], "enable-target-os-checking">,
   HelpText<"Enable checking the target OS of serialized modules">;

lib/AST/ASTDumper.cpp

@@ -1689,6 +1689,7 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
       << " decl=";
     E->getDeclRef().dump(OS);
     OS << E->getAccessSemantics();
+    OS << " function_ref=" << getFunctionRefKindStr(E->getFunctionRefKind());
     OS << " specialized=" << (E->isSpecialized()? "yes" : "no");
 
     for (auto TR : E->getGenericArgs()) {
@@ -1721,7 +1722,8 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     printCommon(E, "overloaded_decl_ref_expr")
       << " name=" << E->getDecls()[0]->getName()
       << " #decls=" << E->getDecls().size()
-      << " specialized=" << (E->isSpecialized()? "yes" : "no");
+      << " specialized=" << (E->isSpecialized()? "yes" : "no")
+      << " function_ref=" << getFunctionRefKindStr(E->getFunctionRefKind());
 
     for (ValueDecl *D : E->getDecls()) {
       OS << '\n';
@@ -1733,7 +1735,8 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
   void visitUnresolvedDeclRefExpr(UnresolvedDeclRefExpr *E) {
     printCommon(E, "unresolved_decl_ref_expr")
       << " name=" << E->getName()
-      << " specialized=" << (E->isSpecialized()? "yes" : "no") << ')';
+      << " specialized=" << (E->isSpecialized()? "yes" : "no") << ')'
+      << " function_ref=" << getFunctionRefKindStr(E->getFunctionRefKind());
   }
   void visitUnresolvedSpecializeExpr(UnresolvedSpecializeExpr *E) {
     printCommon(E, "unresolved_specialize_expr") << '\n';

lib/AST/Expr.cpp

@@ -30,6 +30,19 @@
 #include "llvm/ADT/Twine.h"
 using namespace swift;
 
+StringRef swift::getFunctionRefKindStr(FunctionRefKind refKind) {
+  switch (refKind) {
+  case FunctionRefKind::Unapplied:
+    return "unapplied";
+  case FunctionRefKind::SingleApply:
+    return "single";
+  case FunctionRefKind::DoubleApply:
+    return "double";
+  case FunctionRefKind::Compound:
+    return "compound";
+  }
+}
+
 //===----------------------------------------------------------------------===//
 // Expr methods.
 //===----------------------------------------------------------------------===//

lib/Frontend/CompilerInvocation.cpp

@@ -792,6 +792,9 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
       = A->getOption().matches(OPT_enable_testable_attr_requires_testable_module);
   }
 
+  Opts.SuppressArgumentLabelsInTypes |=
+    Args.hasArg(OPT_suppress_argument_labels_in_types);
+
   if (const Arg *A = Args.getLastArg(OPT_debug_constraints_attempt)) {
     unsigned attempt;
     if (StringRef(A->getValue()).getAsInteger(10, attempt)) {

lib/Sema/CMakeLists.txt

@@ -20,7 +20,6 @@ add_swift_library(swiftSema STATIC
   IterativeTypeChecker.cpp
   MiscDiagnostics.cpp
   NameBinding.cpp
-  OverloadChoice.cpp
   PlaygroundTransform.cpp
   SourceLoader.cpp
   TypeCheckAttr.cpp