---

yaml
---
r: 276479
b: refs/heads/master
c: 85ee550
h: refs/heads/master
i:
  276477: 076875b
  276475: 3c2ce24
  276471: a994877
  276463: d775d62
  276447: c7d6790
  276415: 4ca5358
  276351: c54072c
  276223: b0fefd7
  275967: 5ec1aca
  275455: 00caeb6
  274431: dece103

Author: gottesmm

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: d7b919ce8b9540fd1251303972da62469fd46323
+refs/heads/master: 85ee5506693be3e4f82b3bc613694e9a1b17abea
 refs/heads/master-next: e1ea272cf30ad8dda92fed0a4f7a6eb23cc519ba
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/AST/DiagnosticsSema.def

@@ -238,8 +238,6 @@ NOTE(inout_change_var_type_if_possible,none,
 ERROR(cannot_pass_rvalue_inout,none,
       "cannot pass immutable value of type %0 as inout argument",
       (Type))
-ERROR(cannot_provide_default_value_inout,none,
-      "cannot provide default value to inout parameter %0", (Identifier))
 
 ERROR(cannot_assign_to_literal,none,
       "cannot assign to a literal value", ())

trunk/include/swift/SIL/SILInstruction.h

@@ -5959,7 +5959,7 @@ class InitExistentialValueInst final
 class InitExistentialRefInst final
     : public UnaryInstructionWithTypeDependentOperandsBase<
           SILInstructionKind::InitExistentialRefInst, InitExistentialRefInst,
-          SingleValueInstruction> {
+          OwnershipForwardingSingleValueInst> {
   friend SILBuilder;
 
   CanType ConcreteType;
@@ -5970,7 +5970,8 @@ class InitExistentialRefInst final
                          ArrayRef<SILValue> TypeDependentOperands,
                          ArrayRef<ProtocolConformanceRef> Conformances)
       : UnaryInstructionWithTypeDependentOperandsBase(
-            DebugLoc, Instance, TypeDependentOperands, ExistentialType),
+            DebugLoc, Instance, TypeDependentOperands, ExistentialType,
+            Instance.getOwnershipKind()),
         ConcreteType(FormalConcreteType), Conformances(Conformances) {}
 
   static InitExistentialRefInst *

trunk/lib/SIL/OperandOwnership.cpp

@@ -161,8 +161,8 @@ CONSTANT_OWNERSHIP_INST(Owned, MustBeInvalidated, DestroyValue)
 CONSTANT_OWNERSHIP_INST(Owned, MustBeInvalidated, ReleaseValue)
 CONSTANT_OWNERSHIP_INST(Owned, MustBeInvalidated, ReleaseValueAddr)
 CONSTANT_OWNERSHIP_INST(Owned, MustBeInvalidated, StrongRelease)
-CONSTANT_OWNERSHIP_INST(Owned, MustBeInvalidated, EndLifetime)
 CONSTANT_OWNERSHIP_INST(Owned, MustBeInvalidated, InitExistentialRef)
+CONSTANT_OWNERSHIP_INST(Owned, MustBeInvalidated, EndLifetime)
 CONSTANT_OWNERSHIP_INST(Any, MustBeLive, AbortApply)
 CONSTANT_OWNERSHIP_INST(Any, MustBeLive, AddressToPointer)
 CONSTANT_OWNERSHIP_INST(Any, MustBeLive, BeginAccess)

trunk/lib/SIL/ValueOwnership.cpp

@@ -77,13 +77,6 @@ CONSTANT_OWNERSHIP_INST(Owned, KeyPath)
 CONSTANT_OWNERSHIP_INST(Owned, InitExistentialValue)
 CONSTANT_OWNERSHIP_INST(Owned, GlobalValue) // TODO: is this correct?
 
-// NOTE: Even though init_existential_ref from a reference counting perspective
-// is not considered to be "owned" since it doesn't affect reference counts,
-// conceptually we want to treat it as an owned value that produces owned
-// things, rather than a forwarding thing since initialization is generally a
-// consuming operation.
-CONSTANT_OWNERSHIP_INST(Owned, InitExistentialRef)
-
 // One would think that these /should/ be unowned. In truth they are owned since
 // objc metatypes do not go through the retain/release fast path. In their
 // implementations of retain/release nothing happens, so this is safe.
@@ -239,6 +232,7 @@ ValueOwnershipKindClassifier::visitForwardingInst(SILInstruction *i,
   }
 FORWARDING_OWNERSHIP_INST(BridgeObjectToRef)
 FORWARDING_OWNERSHIP_INST(ConvertFunction)
+FORWARDING_OWNERSHIP_INST(InitExistentialRef)
 FORWARDING_OWNERSHIP_INST(OpenExistentialRef)
 FORWARDING_OWNERSHIP_INST(RefToBridgeObject)
 FORWARDING_OWNERSHIP_INST(SelectValue)

trunk/lib/SILGen/SILGenPattern.cpp

@@ -1868,37 +1868,44 @@ void PatternMatchEmission::emitEnumElementObjectDispatch(
     // instruction to receive the enum case data if it has any.
 
     SILType eltTy;
-    bool hasElt = false;
-    if (elt->hasAssociatedValues()) {
+    bool hasNonVoidAssocValue = false;
+    bool hasAssocValue = elt->hasAssociatedValues();
+    if (hasAssocValue) {
       eltTy = src.getType().getEnumElementType(elt, SGF.SGM.M);
-      hasElt = !eltTy.getASTType()->isVoid();
+      hasNonVoidAssocValue = !eltTy.getASTType()->isVoid();
     }
 
     ConsumableManagedValue eltCMV, origCMV;
 
-    // Empty cases.  Try to avoid making an empty tuple value if it's
-    // obviously going to be ignored.  This assumes that we won't even
-    // try to touch the value in such cases, although we may touch the
-    // cleanup (enough to see that it's not present).
-    if (!hasElt) {
-      bool hasNonAny = false;
-      for (auto &specRow : specializedRows) {
-        auto pattern = specRow.Patterns[0];
-        if (pattern &&
-            !isa<AnyPattern>(pattern->getSemanticsProvidingPattern())) {
-          hasNonAny = true;
-          break;
+    // Void (i.e. empty) cases.
+    //
+    if (!hasNonVoidAssocValue) {
+      // Inline constructor.
+      eltCMV = [&]() -> ConsumableManagedValue {
+        // If we have an associated value, rather than no payload at all, we
+        // still need to create the argument. So do that instead of creating the
+        // empty-tuple. Otherwise, we need to create undef or the empty-tuple.
+        if (hasAssocValue) {
+          return {SGF.B.createOwnedPhiArgument(eltTy),
+                  CastConsumptionKind::TakeAlways};
         }
-      }
 
-      SILValue result;
-      if (hasNonAny) {
-        result = SGF.emitEmptyTuple(loc);
-      } else {
-        result = SILUndef::get(SGF.SGM.Types.getEmptyTupleType(), SGF.F);
-      }
-      origCMV = ConsumableManagedValue::forUnmanaged(result);
-      eltCMV = origCMV;
+        // Otherwise, try to avoid making an empty tuple value if it's obviously
+        // going to be ignored. This assumes that we won't even try to touch the
+        // value in such cases, although we may touch the cleanup (enough to see
+        // that it's not present).
+        bool hasNonAny =
+            llvm::any_of(specializedRows, [&](const SpecializedRow &row) {
+              auto *p = row.Patterns[0];
+              return p && !isa<AnyPattern>(p->getSemanticsProvidingPattern());
+            });
+        if (hasNonAny) {
+          return ConsumableManagedValue::forUnmanaged(SGF.emitEmptyTuple(loc));
+        }
+
+        return ConsumableManagedValue::forUnmanaged(
+            SILUndef::get(SGF.SGM.Types.getEmptyTupleType(), SGF.F));
+      }();
 
       // Okay, specialize on the argument.
     } else {

trunk/lib/SILOptimizer/PassManager/PassPipeline.cpp

@@ -639,24 +639,25 @@ SILPassPipelinePlan
 SILPassPipelinePlan::getOnonePassPipeline(const SILOptions &Options) {
   SILPassPipelinePlan P(Options);
 
-  // First serialize the SIL if we are asked to.
-  P.startPipeline("Serialization");
-  P.addSerializeSILPass();
-
-  // And then strip ownership...
-  if (!Options.StripOwnershipDuringDiagnosticsPipeline)
-    P.addOwnershipModelEliminator();
+  // First specialize user-code.
+  P.startPipeline("Prespecialization");
+  P.addUsePrespecialized();
 
-  // Finally perform some small transforms.
   P.startPipeline("Rest of Onone");
-  P.addUsePrespecialized();
 
   // Has only an effect if the -assume-single-thread option is specified.
   P.addAssumeSingleThreaded();
 
   // Has only an effect if the -gsil option is specified.
   P.addSILDebugInfoGenerator();
 
+  // Finally serialize the SIL if we are asked to.
+  P.addSerializeSILPass();
+
+  // And then strip ownership before we IRGen.
+  if (!Options.StripOwnershipDuringDiagnosticsPipeline)
+    P.addOwnershipModelEliminator();
+
   return P;
 }
 

trunk/lib/Sema/TypeCheckExpr.cpp

@@ -217,9 +217,6 @@ TypeChecker::lookupPrecedenceGroupForInfixOperator(DeclContext *DC, Expr *E) {
 /// 'findLHS(DC, expr, '==')' returns nullptr.
 Expr *TypeChecker::findLHS(DeclContext *DC, Expr *E, Identifier name) {
   auto right = lookupPrecedenceGroupForOperator(*this, DC, name, E->getEndLoc());
-  if (!right)
-    return nullptr;
-
   while (true) {
 
     // Look through implicit conversions.

trunk/lib/Sema/TypeCheckPattern.cpp

@@ -863,14 +863,6 @@ bool TypeChecker::typeCheckParameterList(ParameterList *PL,
         param->setSpecifier(VarDecl::Specifier::Owned);
       }
     }
-
-    if (param->isInOut() && param->isDefaultArgument()) {
-      diagnose(param->getDefaultValue()->getLoc(),
-               swift::diag::cannot_provide_default_value_inout,
-               param->getName());
-      param->markInvalid();
-      hadError = true;
-    }
   }
 
   return hadError;

trunk/test/SIL/ownership-verifier/over_consume.sil

@@ -29,12 +29,6 @@ class SuperKlass {
 class Klass : SuperKlass {
 }
 
-typealias AnyObject = Builtin.AnyObject
-
-class ClassProtConformingRef {}
-protocol ClassProt : AnyObject {}
-extension ClassProtConformingRef : ClassProt {}
-
 ///////////
 // Tests //
 ///////////
@@ -458,30 +452,4 @@ bb0(%0 : @owned $Klass):
   dealloc_stack %1 : $*SuperKlass
   %9999 = tuple()
   return %9999 : $()
-}
-
-// CHECK-LABEL: Function: 'init_existential_ref_not_forwarding'
-// CHECK: Have operand with incompatible ownership?!
-// CHECK: Value: %0 = argument of bb0 : $ClassProtConformingRef
-// CHECK: User:   %2 = init_existential_ref %0 : $ClassProtConformingRef : $ClassProtConformingRef, $ClassProt
-// CHECK: Operand Number: 0
-// CHECK: Conv: guaranteed
-// CHECK: OwnershipMap:
-// CHECK: -- OperandOwnershipKindMap --
-// CHECK: unowned:  No.
-// CHECK: owned: Yes. Liveness: MustBeInvalidated
-// CHECK: guaranteed:  No.
-// CHECK: any: Yes. Liveness: MustBeLive
-// CHECK-NOT: init_existential_ref %1
-// CHECK: Function: 'init_existential_ref_not_forwarding'
-// CHECK: Error! Found a leaked owned value that was never consumed.
-// CHECK: Value:   %2 = init_existential_ref %0 : $ClassProtConformingRef : $ClassProtConformingRef, $ClassProt
-// CHECK-NOT: init_existential_ref %1
-sil [ossa] @init_existential_ref_not_forwarding : $@convention(thin) (@guaranteed ClassProtConformingRef, @owned ClassProtConformingRef) -> @owned (ClassProt, ClassProt) {
-bb0(%0 : @guaranteed $ClassProtConformingRef, %1 : @owned $ClassProtConformingRef):
-  %2 = init_existential_ref %0 : $ClassProtConformingRef : $ClassProtConformingRef, $ClassProt
-  %3 = copy_value %2 : $ClassProt
-  %4 = init_existential_ref %1 : $ClassProtConformingRef : $ClassProtConformingRef, $ClassProt
-  %5 = tuple(%3 : $ClassProt, %4 : $ClassProt)
-  return %5 : $(ClassProt, ClassProt)
-}
+}

trunk/test/SILGen/switch.swift

@@ -1291,3 +1291,15 @@ indirect enum SR6664_Base<Element> {
     }
   }
 }
+
+// Make sure that we properly create switch_enum success arguments if we have an
+// associated type that is a void type.
+func testVoidType() {
+  let x: Optional<()> = ()
+  switch x {
+  case .some(let x):
+    break
+  case .none:
+    break
+  }
+}

trunk/test/decl/func/default-values.swift

@@ -122,16 +122,3 @@ struct X<T> {
 
 let testXa: X<Int> = .foo(i: 0)
 let testXb: X<Int> = .bar
-
-// SR-10062
-
-var aLiteral = 1
-let bLiteral = 2
-
-func inoutFuncWithDefaultArg1(x: inout Int = 1) {} // expected-error {{cannot provide default value to inout parameter 'x'}}
-func inoutFuncWithDefaultArg2(x: inout Int = bLiteral) {} // expected-error {{cannot provide default value to inout parameter 'x'}}
-func inoutFuncWithDefaultArg3(x: inout Int = aLiteral) {} // expected-error {{cannot provide default value to inout parameter 'x'}}
-func inoutFuncWithDefaultArg4(x: inout Int = &aLiteral) {} // expected-error {{cannot provide default value to inout parameter 'x'}}
-func inoutFuncWithDefaultArg5(x: inout Int = &bLiteral) {} // expected-error {{cannot provide default value to inout parameter 'x'}}
-func inoutFuncWithDefaultArg6(x: inout Int = #file) {} // expected-error {{cannot provide default value to inout parameter 'x'}}
-func inoutFuncWithDefaultArg7(_: inout Int = 1) {} // expected-error {{cannot provide default value to inout parameter '_'}}

trunk/test/expr/expressions.swift

@@ -844,7 +844,7 @@ func inoutTests(_ arr: inout Int) {
 
 // <rdar://problem/20802757> Compiler crash in default argument & inout expr
 var g20802757 = 2
-func r20802757(_ z: inout Int = &g20802757) { // expected-error {{cannot provide default value to inout parameter 'z'}}
+func r20802757(_ z: inout Int = &g20802757) { // expected-error {{use of extraneous '&'}}
   print(z)
 }
 

trunk/test/sil-passpipeline-dump/basic.test-sh

@@ -3,13 +3,12 @@
 
 // CHECK: [
 // CHECK:     [
-// CHECK:         "Serialization",
-// CHECK:         ["SerializeSILPass","serialize-sil"]
+// CHECK:         "Prespecialization",
+// CHECK-NEXT:         ["UsePrespecialized","use-prespecialized"]
 // CHECK:     ],
 // CHECK:     [
 // CHECK:         "Rest of Onone",
-// CHECK:         ["UsePrespecialized","use-prespecialized"],
-// CHECK:         ["AssumeSingleThreaded","sil-assume-single-threaded"],
-// CHECK:         ["SILDebugInfoGenerator","sil-debuginfo-gen"]
+// CHECK-NEXT:         ["AssumeSingleThreaded","sil-assume-single-threaded"],
+// CHECK-NEXT:         ["SILDebugInfoGenerator","sil-debuginfo-gen"]
 // CHECK:     ]
-// CHECK: ]
+// CHECK: ]