Always emit enum cases as normal applies

Author: CodaFi

lib/Parse/ParsePattern.cpp

@@ -407,9 +407,17 @@ template <typename T>
 static TypeRepr *
 validateParameterWithSpecifier(Parser &parser,
                                Parser::ParsedParameter &paramInfo,
-                               StringRef specifierName) {
+                               StringRef specifierName,
+                               bool parsingEnumElt) {
   auto type = paramInfo.Type;
   auto loc = paramInfo.SpecifierLoc;
+  // If we're validating an enum element, 'inout' is not allowed
+  // at all - Sema will catch this for us.  In all other contexts, we
+  // assume the user put 'inout' in the wrong place and offer a fixit.
+  if (parsingEnumElt) {
+    return new (parser.Context) T(type, loc);
+  }
+
   if (isa<SpecifierTypeRepr>(type)) {
     parser.diagnose(loc, diag::parameter_specifier_repeated).fixItRemove(loc);
   } else {
@@ -446,10 +454,11 @@ mapParsedParameters(Parser &parser,
                                      argNameLoc, argName,
                                      paramNameLoc, paramName, Type(),
                                      parser.CurDeclContext);
+    bool parsingEnumElt
+      = (paramContext == Parser::ParameterContextKind::EnumElement);
     // If we're not parsing an enum case, lack of a SourceLoc for both
     // names indicates the parameter is synthetic.
-    if (paramContext != Parser::ParameterContextKind::EnumElement &&
-        argNameLoc.isInvalid() && paramNameLoc.isInvalid())
+    if (!parsingEnumElt && argNameLoc.isInvalid() && paramNameLoc.isInvalid())
       param->setImplicit();
 
     // If we diagnosed this parameter as a parse error, propagate to the decl.
@@ -458,21 +467,19 @@ mapParsedParameters(Parser &parser,
 
     // If a type was provided, create the type for the parameter.
     if (auto type = paramInfo.Type) {
-      if (paramContext != Parser::ParameterContextKind::EnumElement) {
-        // If 'inout' was specified, turn the type into an in-out type.
-        if (paramInfo.SpecifierKind == VarDecl::Specifier::InOut) {
-          type = validateParameterWithSpecifier<InOutTypeRepr>(parser,
-                                                               paramInfo,
-                                                               "inout");
-        } else if (paramInfo.SpecifierKind == VarDecl::Specifier::Shared) {
-          type = validateParameterWithSpecifier<SharedTypeRepr>(parser,
-                                                                paramInfo,
-                                                                "__shared");
-        } else if (paramInfo.SpecifierKind == VarDecl::Specifier::Owned) {
-          type = validateParameterWithSpecifier<OwnedTypeRepr>(parser,
-                                                               paramInfo,
-                                                               "__owned");
-        }
+      // If 'inout' was specified, turn the type into an in-out type.
+      if (paramInfo.SpecifierKind == VarDecl::Specifier::InOut) {
+        type = validateParameterWithSpecifier<InOutTypeRepr>(parser, paramInfo,
+                                                             "inout",
+                                                             parsingEnumElt);
+      } else if (paramInfo.SpecifierKind == VarDecl::Specifier::Shared) {
+        type = validateParameterWithSpecifier<SharedTypeRepr>(parser, paramInfo,
+                                                              "__shared",
+                                                              parsingEnumElt);
+      } else if (paramInfo.SpecifierKind == VarDecl::Specifier::Owned) {
+        type = validateParameterWithSpecifier<OwnedTypeRepr>(parser, paramInfo,
+                                                             "__owned",
+                                                             parsingEnumElt);
       }
       param->getTypeLoc() = TypeLoc(type);
     } else if (paramContext != Parser::ParameterContextKind::Closure) {

lib/SILGen/ArgumentSource.h

@@ -223,18 +223,6 @@ class ArgumentSource {
   bool isRValue() const & { return StoredKind == Kind::RValue; }
   bool isLValue() const & { return StoredKind == Kind::LValue; }
   bool isTuple() const & { return StoredKind == Kind::Tuple; }
-  bool isTupleShuffleExpr() const & {
-    if (StoredKind == Kind::Expr) {
-      auto *e = asKnownExpr();
-      if (auto *TSE = dyn_cast<TupleShuffleExpr>(e)) {
-        return llvm::any_of(TSE->getElementMapping(), [](const int &i) {
-          return i == TupleShuffleExpr::DefaultInitialize
-              || i == TupleShuffleExpr::CallerDefaultInitialize;
-        });
-      }
-    }
-    return false;
-  }
 
   /// Given that this source is storing an RValue, extract and clear
   /// that value.

lib/SILGen/SILGenApply.cpp

@@ -3481,10 +3481,6 @@ class CallEmission {
     extraSites.push_back(std::move(site));
   }
 
-  bool isArgTupleShuffle() const {
-    return ArgValue.isTupleShuffleExpr();
-  }
-  
   /// Add a level of function application by passing in its possibly
   /// unevaluated arguments and their formal type
   template<typename...T>
@@ -3639,12 +3635,6 @@ CallEmission::applyFirstLevelCallee(SGFContext C) {
     return applyPartiallyAppliedSuperMethod(C);
   }
 
-  if (isEnumElementConstructor() && !llvm::any_of(uncurriedSites, [](const CallSite &s){
-     return s.isArgTupleShuffle();
-   })) {
-    return applyEnumElementConstructor(C);
-  }
-
   return applyNormalCall(C);
 }
 

test/Compatibility/enum_element_pattern.swift

@@ -26,7 +26,7 @@ func testE(e: E) {
     break
   case .C(): // Ok.
     break
-  case .D(let payload):
+  case .D(let payload): // Ok. 'payload' has type '()'.
     let _: () = payload
     break
   default:
@@ -35,7 +35,7 @@ func testE(e: E) {
 
   guard
     case .C() = e, // Ok. SILGen assert this, but no-assert Swift3 GM build didn't assert.
-    case .D(let payload) = e
+    case .D(let payload) = e // FIXME: Should be rejected. Swift3 IRGen verifier did catch this.
   else { return }
   print(payload)
 }
@@ -49,6 +49,6 @@ do {
   try canThrow()
 } catch E.A() { // Ok.
   // ..
-} catch E.B(let payload) {
+} catch E.B(let payload) { // Ok. 'payload' has type '()'.
   let _: () = payload
 }

test/IRGen/class_resilience_thunks.swift

@@ -29,10 +29,10 @@ public func testDispatchThunkDerived(d: Derived) {
   // CHECK: call swiftcc void @"$S22resilient_class_thunks4BaseC6takesTyyxFTj"(%swift.opaque* noalias nocapture dereferenceable({{4|8}}) {{%.*}}, %T22resilient_class_thunks4BaseC* swiftself {{%.*}})
   d.takesT(0)
 
-  // CHECK: call swiftcc void @"$S22resilient_class_thunks7DerivedC8takesIntyySiSgFTj"([[INT]] 0, i8 1, %T22resilient_class_thunks7DerivedC* swiftself %0)
+  // CHECK: call swiftcc void @"$S22resilient_class_thunks7DerivedC8takesIntyySiSgFTj"([[INT]] {{%.*}}, i8 {{%.*}}, %T22resilient_class_thunks7DerivedC* swiftself %0)
   d.takesInt(nil)
 
-  // CHECK: call swiftcc void @"$S22resilient_class_thunks4BaseC14takesReferenceyyAA6ObjectCFTj"(%T22resilient_class_thunks6ObjectC* null, %T22resilient_class_thunks4BaseC* swiftself {{%.*}})
+  // CHECK: call swiftcc void @"$S22resilient_class_thunks4BaseC14takesReferenceyyAA6ObjectCFTj"(%T22resilient_class_thunks6ObjectC* {{%.*}}, %T22resilient_class_thunks4BaseC* swiftself {{%.*}})
   d.takesReference(nil)
 
   // CHECK: ret void

test/IRGen/dynamic_self_metadata.swift

@@ -15,11 +15,11 @@
 class C {
   class func fromMetatype() -> Self? { return nil }
   // CHECK-LABEL: define hidden swiftcc i64 @"$S21dynamic_self_metadata1CC12fromMetatypeACXDSgyFZ"(%swift.type* swiftself)
-  // CHECK: ret i64 0
+  // CHECK: ret i64 {{%.*}}
 
   func fromInstance() -> Self? { return nil }
   // CHECK-LABEL: define hidden swiftcc i64 @"$S21dynamic_self_metadata1CC12fromInstanceACXDSgyF"(%T21dynamic_self_metadata1CC* swiftself)
-  // CHECK: ret i64 0
+  // CHECK: ret i64 {{%.*}}
 
   func dynamicSelfArgument() -> Self? {
     return id(nil)

test/IRGen/enum_resilience.swift

@@ -119,10 +119,22 @@ public func constructResilientEnumPayload(_ s: Size) -> Medium {
 // CHECK-NEXT: [[VWT_ADDR:%.*]] = getelementptr inbounds i8**, i8*** [[METADATA_ADDR]], [[INT:i32|i64]] -1
 // CHECK-NEXT: [[VWT:%.*]] = load i8**, i8*** [[VWT_ADDR]]
 
+// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 9
+// CHECK-NEXT: [[WITNESS:%.*]] = load i8*, i8** [[WITNESS_ADDR]], align 8, !invariant.load !11
+// CHECK-NEXT: [[ALLOCA_SIZE:%.*]] = ptrtoint i8* [[WITNESS]] to i64
+// CHECK-NEXT: [[STACK:%.*]] = alloca i8, i64 [[ALLOCA_SIZE]], align 16
+// CHECK-NEXT: call void @llvm.lifetime.start.p0i8(i64 -1, i8* [[STACK]])
+// CHECK-NEXT: [[DEST:%.*]] = bitcast i8* [[STACK]] to %swift.opaque*
+
 // CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 2
 // CHECK-NEXT: [[WITNESS:%.*]]  = load i8*, i8** [[WITNESS_ADDR]]
 // CHECK-NEXT: [[WITNESS_FN:%.*]] = bitcast i8* [[WITNESS]]
-// CHECK-NEXT: [[COPY:%.*]] = call %swift.opaque* %initializeWithCopy(%swift.opaque* noalias %0, %swift.opaque* noalias %1, %swift.type* [[METADATA]])
+// CHECK-NEXT: [[COPY:%.*]] = call %swift.opaque* %initializeWithCopy(%swift.opaque* noalias [[DEST]], %swift.opaque* noalias %1, %swift.type* [[METADATA]])
+
+// CHECK-NEXT: [[WITNESS_ADDR:%.*]] = getelementptr inbounds i8*, i8** [[VWT]], i32 4
+// CHECK-NEXT: [[WITNESS:%.*]]  = load i8*, i8** [[WITNESS_ADDR]]
+// CHECK-NEXT: [[WITNESS_FN:%.*]] = bitcast i8* [[WITNESS]]
+// CHECK-NEXT: [[COPY:%.*]] = call %swift.opaque* %initializeWithTake(%swift.opaque* noalias %0, %swift.opaque* noalias [[DEST]], %swift.type* [[METADATA]])
 
 // CHECK-NEXT: [[METADATA2:%.*]] = call %swift.type* @"$S14resilient_enum6MediumOMa"()
 // CHECK-NEXT: [[METADATA_ADDR2:%.*]] = bitcast %swift.type* [[METADATA2]] to i8***
@@ -139,6 +151,9 @@ public func constructResilientEnumPayload(_ s: Size) -> Medium {
 // CHECK-NEXT: [[WITNESS_FN:%.*]] = bitcast i8* [[WITNESS]]
 // CHECK-NEXT: call void [[WITNESS_FN]](%swift.opaque* noalias %1, %swift.type* [[METADATA]])
 
+// CHECK-NEXT: [[STACK:%.*]] = bitcast %swift.opaque* [[DEST]] to i8*
+// CHECK-NEXT: call void @llvm.lifetime.end.p0i8(i64 -1, i8* [[STACK]])
+
 // CHECK-NEXT: ret void
   return Medium.Postcard(s)
 }

test/SILGen/argument_shuffle_swift3.swift

@@ -17,10 +17,14 @@ func g(x: Any) {
   // CHECK: apply [[FN:%.*]]({{.*}}) : $@convention(thin) (@in Any) -> ()
   fn(data: x)
 
-  // CHECK: inject_enum_addr {{.*}} : $*HasAnyCase, #HasAnyCase.any!enumelt.1
+  // CHECK:      // function_ref HasAnyCase.any(_:)
+  // CHECK-NEXT: [[ENUM_CASE:%.*]] = function_ref @$S23argument_shuffle_swift310HasAnyCaseO3anyyACypcACmF
+  // CHECK-NEXT: apply [[ENUM_CASE]]({{.*}})
   _ = HasAnyCase.any(123)
 
-  // CHECK: inject_enum_addr {{.*}} : $*HasAnyCase, #HasAnyCase.any!enumelt.1
+  // CHECK:      // function_ref HasAnyCase.any(_:)
+  // CHECK-NEXT: [[ENUM_CASE:%.*]] = function_ref @$S23argument_shuffle_swift310HasAnyCaseO3anyyACypcACmF
+  // CHECK-NEXT: apply [[ENUM_CASE]]({{.*}})
   _ = HasAnyCase.any(data: 123)
 
   // CHECK: return

test/SILGen/default_arguments.swift

@@ -377,19 +377,19 @@ enum default_args {
   case defarg2(i: Int, d: Double = 3.14159, s: String = "Hello")
 }
 
-// CHECK-LABEL: sil hidden @_T017default_arguments18testDefaultArgEnumyyF
+// CHECK-LABEL: sil hidden @$S17default_arguments18testDefaultArgEnumyyF
 func testDefaultArgEnum() {
   // CHECK: [[METATYPE_DEF_1:%[0-9]+]] = metatype $@thin default_args.Type
 
   // implicit closure #1
-  // CHECK: [[THIN_FILE_ARG_THUNK1:%[0-9]+]] = function_ref @_T017default_arguments18testDefaultArgEnumyyFSSyXKfu_ : $@convention(thin) () -> @owned String
+  // CHECK: [[THIN_FILE_ARG_THUNK1:%[0-9]+]] = function_ref @$S17default_arguments18testDefaultArgEnumyyFSSyXAfu_ : $@convention(thin) () -> @owned String
   // CHECK-NEXT: [[THICK_FILE_ARG_THUNK1:%[0-9]+]] = thin_to_thick_function [[THIN_FILE_ARG_THUNK1]] : $@convention(thin) () -> @owned String to $@callee_guaranteed () -> @owned String
 
   // implicit closure #2
-  // CHECK: [[THIN_LINE_ARG_THUNK2:%[0-9]+]] = function_ref @_T017default_arguments18testDefaultArgEnumyyFSiyXKfu0_ : $@convention(thin) () -> Int
+  // CHECK: [[THIN_LINE_ARG_THUNK2:%[0-9]+]] = function_ref @$S17default_arguments18testDefaultArgEnumyyFSiyXAfu0_ : $@convention(thin) () -> Int
   // CHECK-NEXT: [[THICK_LINE_ARG_THUNK2:%[0-9]+]] = thin_to_thick_function [[THIN_LINE_ARG_THUNK2]] : $@convention(thin) () -> Int to $@callee_guaranteed () -> Int
 
-  // CHECK: [[DEF1_THUNK:%[0-9]+]] = function_ref @_T017default_arguments0A5_argsO7defarg1yACSSyXK_SiyXKtcACmF : $@convention(method) (@owned @callee_guaranteed () -> @owned String, @owned @callee_guaranteed () -> Int, @thin default_args.Type) -> @owned default_args
+  // CHECK: [[DEF1_THUNK:%[0-9]+]] = function_ref @$S17default_arguments0A5_argsO7defarg1yACSSyXA_SiyXAtcACmF : $@convention(method) (@owned @callee_guaranteed () -> @owned String, @owned @callee_guaranteed () -> Int, @thin default_args.Type) -> @owned default_args
 
   // CHECK: apply [[DEF1_THUNK]]([[THICK_FILE_ARG_THUNK1]], [[THICK_LINE_ARG_THUNK2]], [[METATYPE_DEF_1]])
   _ = default_args.defarg1()
@@ -400,14 +400,14 @@ func testDefaultArgEnum() {
   // CHECK: integer_literal $Builtin.Int
 
   // default argument 1
-  // CHECK: [[DOUBLE_ARG_THUNK:%[0-9]+]] = function_ref @_T017default_arguments0A5_argsOfA0_ : $@convention(thin) () -> Double
+  // CHECK: [[DOUBLE_ARG_THUNK:%[0-9]+]] = function_ref @$S17default_arguments0A5_argsOfA0_ : $@convention(thin) () -> Double
   // CHECK-NEXT: [[DOUBLE_ARG:%[0-9]+]] = apply [[DOUBLE_ARG_THUNK]]() : $@convention(thin) () -> Double
 
   // default argument 2
-  // CHECK: [[STRING_ARG_THUNK:%[0-9]+]] = function_ref @_T017default_arguments0A5_argsOfA1_ : $@convention(thin) () -> @owned String
+  // CHECK: [[STRING_ARG_THUNK:%[0-9]+]] = function_ref @$S17default_arguments0A5_argsOfA1_ : $@convention(thin) () -> @owned String
   // CHECK-NEXT: [[STRING_ARG:%[0-9]+]] = apply [[STRING_ARG_THUNK]]() : $@convention(thin) () -> @owned String
 
-  // CHECK: [[DEF2_THUNK:%[0-9]+]] = function_ref @_T017default_arguments0A5_argsO7defarg2yACSi_SdSStcACmF : $@convention(method) (Int, Double, @owned String, @thin default_args.Type) -> @owned default_args
+  // CHECK: [[DEF2_THUNK:%[0-9]+]] = function_ref @$S17default_arguments0A5_argsO7defarg2yACSi_SdSStcACmF : $@convention(method) (Int, Double, @owned String, @thin default_args.Type) -> @owned default_args
 
   // CHECK: apply [[DEF2_THUNK]]({{%[0-9]+}}, [[DOUBLE_ARG]], [[STRING_ARG]], [[METATYPE_DEF_2]])
   _ = default_args.defarg2(i: 5)

test/SILGen/default_arguments_imported.swift

@@ -8,7 +8,9 @@ import gizmo
 
 // CHECK-LABEL: sil hidden @$S26default_arguments_imported9testGizmo{{[_0-9a-zA-Z]*}}F
 func testGizmo(gizmo: Gizmo) {
-  // CHECK: enum $Optional<@callee_guaranteed (@owned Optional<Gizmo>) -> ()>, #Optional.none!enumelt
+  // CHECK: // function_ref Optional.none<A>(_:)
+  // CHECK-NEXT: [[ENUM_CASE:%.*]] = function_ref @$SSq4noneyxSgABmlF : $@convention(method) <τ_0_0> (@thin Optional<τ_0_0>.Type) -> @out Optional<τ_0_0>
+  // CHECK-NEXT: apply [[ENUM_CASE]]<(Gizmo?) -> ()>({{%.*}}, {{%.*}})
   // CHECK: objc_method [[SELF:%[0-9]+]] : $Gizmo, #Gizmo.enumerateSubGizmos!1.foreign
   gizmo.enumerateSubGizmos()
 } // CHECK: } // end sil function '$S26default_arguments_imported9testGizmo5gizmoySo0E0C_tF'
@@ -24,7 +26,9 @@ func testNonnullDictionary(gizmo: Gizmo) {
 // CHECK-LABEL: sil hidden @$S26default_arguments_imported22testNullableDictionary5gizmoySo5GizmoC_tF
 func testNullableDictionary(gizmo: Gizmo) {
   // CHECK-NOT: dictionaryLiteral
-  // CHECK: enum $Optional<Dictionary<AnyHashable, Any>>, #Optional.none!enumelt
+  // CHECK: // function_ref Optional.none<A>(_:)
+  // CHECK-NEXT: [[ENUM_CASE:%.*]] = function_ref @$SSq4noneyxSgABmlF : $@convention(method) <τ_0_0> (@thin Optional<τ_0_0>.Type) -> @out Optional<τ_0_0>
+  // CHECK-NEXT: apply [[ENUM_CASE]]<[AnyHashable : Any]>({{%.*}}, {{%.*}})
   // CHECK: objc_method [[SELF:%[0-9]+]] : $Gizmo, #Gizmo.doTheOtherThing!1.foreign
   gizmo.doTheOtherThing()
 } // CHECK: } // end sil function '$S26default_arguments_imported22testNullableDictionary5gizmoySo5GizmoC_tF'