Merge pull request #3881 from DougGregor/enable-se-0111

SE-0111: Enable removal of argument labels in function types by default

Author: DougGregor

CHANGELOG.md

@@ -3,6 +3,37 @@ Note: This is in reverse chronological order, so newer entries are added to the
 Swift 3.0
 ---------
 
+* [SE-0111](https://github.com/apple/swift-evolution/blob/master/proposals/0111-remove-arg-label-type-significance.md):
+
+  Argument labels have been removed from Swift function types. Instead, they are
+  part of the name of a function, subscript, or initializer. Calls to a function
+  or initializer, or uses of a subscript, still require argument labels, as they
+  always have:
+
+  ```swift
+    func doSomething(x: Int, y: Int) { }
+    doSomething(x: 0, y: 0)     // argument labels are required
+  ```
+
+  However, unapplied references to functions or initializers no longer carry
+  argument labels. For example:
+
+  ```swift
+  let f = doSomething(x:y:)     // inferred type is now (Int, Int) -> Void
+  ```
+
+  Additionally, explicitly-written function types can no longer carry argument
+  labels, although one can still provide parameter name for documentation
+  purposes using the '_' in the argument label position:
+
+  ```swift
+  typealias CompletionHandler =
+     (token: Token, error: Error?) -> Void   // error: function types cannot have argument labels
+
+  typealias CompletionHandler =
+     (_ token: Token, _ error: Error?) -> Void   // error: okay: names are for documentation purposes
+  ```
+
 * [SE-0025](https://github.com/apple/swift-evolution/blob/master/proposals/0025-scoped-access-level.md): A declaration marked as `private` can now only be accessed within the lexical scope it is declared in (essentially the enclosing curly braces `{}`). A `private` declaration at the top level of a file can be accessed anywhere in that file, as in Swift 2. The access level formerly known as `private` is now called `fileprivate`.
 
 * [SE-0131](https://github.com/apple/swift-evolution/blob/master/proposals/0131-anyhashable.md):

lib/AST/ASTPrinter.cpp

@@ -3835,16 +3835,14 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
 
     // If we're stripping argument labels from types, do it when printing.
     Type inputType = T->getInput();
-    if (inputType->getASTContext().LangOpts.SuppressArgumentLabelsInTypes) {
-      if (auto tupleTy = dyn_cast<TupleType>(inputType.getPointer())) {
-        SmallVector<TupleTypeElt, 4> elements;
-        elements.reserve(tupleTy->getNumElements());
-        for (const auto &elt : tupleTy->getElements()) {
-          elements.push_back(TupleTypeElt(elt.getType(), Identifier(),
-                                          elt.isVararg()));
-        }
-        inputType = TupleType::get(elements, inputType->getASTContext());
+    if (auto tupleTy = dyn_cast<TupleType>(inputType.getPointer())) {
+      SmallVector<TupleTypeElt, 4> elements;
+      elements.reserve(tupleTy->getNumElements());
+      for (const auto &elt : tupleTy->getElements()) {
+        elements.push_back(TupleTypeElt(elt.getType(), Identifier(),
+                                        elt.isVararg()));
       }
+      inputType = TupleType::get(elements, inputType->getASTContext());
     }
 
     bool needsParens =

lib/Parse/ParseType.cpp

@@ -681,7 +681,7 @@ ParserResult<TupleTypeRepr> Parser::parseTypeTupleBody() {
       SourceLoc secondNameLoc = std::get<3>(currentLabel);
 
       // True tuples have labels.
-      if (!isFunctionType || !Context.LangOpts.SuppressArgumentLabelsInTypes) {
+      if (!isFunctionType) {
         // If there were two names, complain.
         if (firstNameLoc.isValid() && secondNameLoc.isValid()) {
           auto diag = diagnose(firstNameLoc, diag::tuple_type_multiple_labels);

lib/SILGen/RValue.cpp

@@ -559,7 +559,17 @@ getElementRange(CanTupleType tupleType, unsigned eltIndex) {
 RValue RValue::extractElement(unsigned n) && {
   assert(isComplete() && "rvalue is not complete");
 
-  auto tupleTy = cast<TupleType>(type);
+  CanTupleType tupleTy = dyn_cast<TupleType>(type);
+	if (!tupleTy) {
+		assert(n == 0);
+    unsigned to = getRValueSize(type);
+		assert(to == values.size());
+		RValue element({llvm::makeArrayRef(values).slice(0, to), type});
+		makeUsed();
+		return element;
+  }
+
+
   auto range = getElementRange(tupleTy, n);
   unsigned from = range.first, to = range.second;
 
@@ -572,8 +582,17 @@ RValue RValue::extractElement(unsigned n) && {
 void RValue::extractElements(SmallVectorImpl<RValue> &elements) && {
   assert(isComplete() && "rvalue is not complete");
 
+  CanTupleType tupleTy = dyn_cast<TupleType>(type);
+	if (!tupleTy) {
+    unsigned to = getRValueSize(type);
+		assert(to == values.size());
+		elements.push_back({llvm::makeArrayRef(values).slice(0, to), type});
+		makeUsed();
+		return;
+  }
+
   unsigned from = 0;
-  for (auto eltType : cast<TupleType>(type).getElementTypes()) {
+  for (auto eltType : tupleTy.getElementTypes()) {
     unsigned to = from + getRValueSize(eltType);
     elements.push_back({llvm::makeArrayRef(values).slice(from, to - from),
                         eltType});

lib/SILGen/SILGenApply.cpp

@@ -2967,19 +2967,27 @@ namespace {
       // If we're working with an r-value, just expand it out and emit
       // all the elements individually.
       if (arg.isRValue()) {
-        CanTupleType substArgType = cast<TupleType>(arg.getSubstType());
-
-        // The original type isn't necessarily a tuple.
-        assert(origParamType.matchesTuple(substArgType));
-
-        auto loc = arg.getKnownRValueLocation();
-        SmallVector<RValue, 4> elts;
-        std::move(arg).asKnownRValue().extractElements(elts);
-        for (auto i : indices(substArgType.getElementTypes())) {
-          emit({ loc, std::move(elts[i]) },
-               origParamType.getTupleElementType(i));
-        }
-        return;
+        if (CanTupleType substArgType =
+                dyn_cast<TupleType>(arg.getSubstType())) {
+	  // The original type isn't necessarily a tuple.
+	  assert(origParamType.matchesTuple(substArgType));
+
+	  auto loc = arg.getKnownRValueLocation();
+	  SmallVector<RValue, 4> elts;
+	  std::move(arg).asKnownRValue().extractElements(elts);
+	  for (auto i : indices(substArgType.getElementTypes())) {
+	    emit({ loc, std::move(elts[i]) },
+		 origParamType.getTupleElementType(i));
+	  }
+	  return;
+	}
+
+	auto loc = arg.getKnownRValueLocation();
+	SmallVector<RValue, 1> elts;
+	std::move(arg).asKnownRValue().extractElements(elts);
+	emit({ loc, std::move(elts[0]) },
+  	       origParamType.getTupleElementType(0));
+	return;
       }
 
       // Otherwise, we're working with an expression.

lib/SILGen/SILGenPoly.cpp

@@ -772,6 +772,16 @@ static void emitForceInto(SILGenFunction &SGF, SILLocation loc,
   temp.finishInitialization(SGF);
 }
 
+/// If the type is a single-element tuple, return the element type.
+static CanType getSingleTupleElement(CanType type) {
+  if (auto tupleType = dyn_cast<TupleType>(type)) {
+    if (tupleType->getNumElements() == 1)
+      return tupleType.getElementType(0);
+  }
+
+  return type;
+}
+
 namespace {
   class TranslateArguments {
     SILGenFunction &SGF;
@@ -804,18 +814,15 @@ namespace {
         if (inputOrigType.isTuple() &&
             inputOrigType.getNumTupleElements() == 1) {
           inputOrigType = inputOrigType.getTupleElementType(0);
-          inputSubstType = cast<TupleType>(inputSubstType).getElementType(0);
+          inputSubstType = getSingleTupleElement(inputSubstType);
           return translate(inputOrigType, inputSubstType,
                            outputOrigType, outputSubstType);
         }
 
         if (outputOrigType.isTuple() &&
             outputOrigType.getNumTupleElements() == 1) {
           outputOrigType = outputOrigType.getTupleElementType(0);
-          if (auto outputSubstTuple = dyn_cast<TupleType>(outputSubstType)) {
-            if (outputSubstTuple->getNumElements() > 0)
-              outputSubstType = outputSubstTuple.getElementType(0);
-          }
+          outputSubstType = getSingleTupleElement(outputSubstType);
           return translate(inputOrigType, inputSubstType,
                            outputOrigType, outputSubstType);
         }

lib/Sema/ConstraintSystem.cpp

@@ -819,9 +819,6 @@ void ConstraintSystem::recordOpenedTypes(
 static unsigned getNumRemovedArgumentLabels(ASTContext &ctx, ValueDecl *decl,
                                             bool isCurriedInstanceReference,
                                             FunctionRefKind functionRefKind) {
-  // Is this functionality enabled at all?
-  if (!ctx.LangOpts.SuppressArgumentLabelsInTypes) return 0;
-
   // Only applicable to functions. Nothing else should have argument labels in
   // the type.
   auto func = dyn_cast<AbstractFunctionDecl>(decl);

lib/Sema/TypeCheckConstraints.cpp

@@ -778,12 +778,9 @@ namespace {
       assert(ExprStack.back() == expr);
       ExprStack.pop_back();
 
-      // When we're suppressing argument labels in types, mark the direct callee
-      // as being a callee.
-      if (TC.Context.LangOpts.SuppressArgumentLabelsInTypes) {
-        if (auto call = dyn_cast<CallExpr>(expr))
-          markDirectCallee(call->getFn());
-      }
+      // Mark the direct callee as being a callee.
+      if (auto call = dyn_cast<CallExpr>(expr))
+        markDirectCallee(call->getFn());
 
       // Fold sequence expressions.
       if (auto seqExpr = dyn_cast<SequenceExpr>(expr)) {

stdlib/private/StdlibUnittest/StringConvertible.swift.gyb

@@ -30,7 +30,7 @@ public struct CustomPrintableValue
   public static var timesDebugDescriptionWasCalled = ResettableValue(0)
 
   public static var descriptionImpl =
-    ResettableValue<(value: Int, identity: Int) -> String>({
+    ResettableValue<(_ value: Int, _ identity: Int) -> String>({
       (value: Int, identity: Int) -> String in
       if identity == 0 {
         return "(value: \(value)).description"
@@ -40,7 +40,7 @@ public struct CustomPrintableValue
     })
 
   public static var debugDescriptionImpl =
-    ResettableValue<(value: Int, identity: Int) -> String>({
+    ResettableValue<(_ value: Int, _ identity: Int) -> String>({
       (value: Int, identity: Int) -> String in
       CustomPrintableValue.timesDescriptionWasCalled.value += 1
       if identity == 0 {
@@ -97,15 +97,15 @@ extension CustomPrintableValue : CustomStringConvertible {
   public var description: String {
     CustomPrintableValue.timesDescriptionWasCalled.value += 1
     return CustomPrintableValue.descriptionImpl.value(
-      value: value, identity: identity)
+      value, identity)
   }
 }
 
 extension CustomPrintableValue : CustomDebugStringConvertible {
   public var debugDescription: String {
     CustomPrintableValue.timesDebugDescriptionWasCalled.value += 1
     return CustomPrintableValue.debugDescriptionImpl.value(
-      value: value, identity: identity)
+      value, identity)
   }
 }
 

stdlib/public/SDK/Dispatch/Data.swift

@@ -82,13 +82,13 @@ public struct DispatchData : RandomAccessCollection, _ObjectiveCBridgeable {
 	}
 
 	public func enumerateBytes(
-		block: @noescape (buffer: UnsafeBufferPointer<UInt8>, byteIndex: Int, stop: inout Bool) -> Void) 
+		block: @noescape (_ buffer: UnsafeBufferPointer<UInt8>, _ byteIndex: Int, _ stop: inout Bool) -> Void) 
 	{
 		_swift_dispatch_data_apply(__wrapped) { (_, offset: Int, ptr: UnsafeRawPointer, size: Int) in
             let bytePtr = ptr.bindMemory(to: UInt8.self, capacity: size)
 			let bp = UnsafeBufferPointer(start: bytePtr, count: size)
 			var stop = false
-			block(buffer: bp, byteIndex: offset, stop: &stop)
+			block(bp, offset, &stop)
 			return stop ? 0 : 1
 		}
 	}