[AST][Sema] Add ValueDecl::hasParameterList

Author: hamishknight

include/swift/AST/Decl.h

@@ -2698,6 +2698,12 @@ class ValueDecl : public Decl {
   /// curried self parameter.
   bool hasCurriedSelf() const;
 
+  /// Returns true if the declaration has a parameter list associated with it.
+  ///
+  /// Note that not all declarations with function interface types have
+  /// parameter lists, for example an enum element without associated values.
+  bool hasParameterList() const;
+
   /// Get the decl for this value's opaque result type, if it has one.
   OpaqueTypeDecl *getOpaqueResultTypeDecl() const;
 
@@ -7152,6 +7158,12 @@ inline bool ValueDecl::hasCurriedSelf() const {
   return false;
 }
 
+inline bool ValueDecl::hasParameterList() const {
+  if (auto *eed = dyn_cast<EnumElementDecl>(this))
+    return eed->hasAssociatedValues();
+  return isa<AbstractFunctionDecl>(this) || isa<SubscriptDecl>(this);
+}
+
 inline bool Decl::isPotentiallyOverridable() const {
   if (isa<VarDecl>(this) ||
       isa<SubscriptDecl>(this) ||

lib/AST/DeclContext.cpp

@@ -317,14 +317,8 @@ ResilienceExpansion DeclContext::getResilienceExpansion() const {
     if (isa<DefaultArgumentInitializer>(dc)) {
       dc = dc->getParent();
 
-      const ValueDecl *VD;
-      if (auto *FD = dyn_cast<AbstractFunctionDecl>(dc)) {
-        VD = FD;
-      } else if (auto *EED = dyn_cast<EnumElementDecl>(dc)) {
-        VD = EED;
-      } else {
-        VD = cast<SubscriptDecl>(dc);
-      }
+      auto *VD = cast<ValueDecl>(dc->getAsDecl());
+      assert(VD->hasParameterList());
 
       auto access =
         VD->getFormalAccessScope(/*useDC=*/nullptr,

lib/AST/Type.cpp

@@ -757,8 +757,10 @@ swift::computeDefaultMap(ArrayRef<AnyFunctionType::Param> params,
 
   // No parameter list means no default arguments - hand back the zeroed
   // bitvector.
-  if (!paramList)
+  if (!paramList) {
+    assert(!paramOwner->hasParameterList());
     return resultVector;
+  }
 
   switch (params.size()) {
   case 0:

lib/Sema/CSRanking.cpp

@@ -471,29 +471,10 @@ static bool isDeclAsSpecializedAs(TypeChecker &tc, DeclContext *dc,
       Type type1 = decl1->getInterfaceType();
       Type type2 = decl2->getInterfaceType();
 
-      /// What part of the type should we check?
-      enum {
-        CheckAll,
-        CheckInput,
-      } checkKind;
-      if (isa<AbstractFunctionDecl>(decl1) || isa<EnumElementDecl>(decl1)) {
-        // Nothing to do: these have the curried 'self' already.
-        if (auto elt = dyn_cast<EnumElementDecl>(decl1)) {
-          checkKind = elt->hasAssociatedValues() ? CheckInput : CheckAll;
-        } else {
-          checkKind = CheckInput;
-        }
-      } else {
-        // Add a curried 'self' type.
+      // Add curried 'self' types if necessary.
+      if (!decl1->hasCurriedSelf()) {
         type1 = type1->addCurriedSelfType(outerDC1);
         type2 = type2->addCurriedSelfType(outerDC2);
-
-        // For a subscript declaration, only look at the input type (i.e., the
-        // indices).
-        if (isa<SubscriptDecl>(decl1))
-          checkKind = CheckInput;
-        else
-          checkKind = CheckAll;
       }
 
       // Construct a constraint system to compare the two declarations.
@@ -613,18 +594,16 @@ static bool isDeclAsSpecializedAs(TypeChecker &tc, DeclContext *dc,
       }
 
       bool fewerEffectiveParameters = false;
-      switch (checkKind) {
-      case CheckAll:
-        // Check whether the first type is a subtype of the second.
+      if (!decl1->hasParameterList()) {
+        // If the decl doesn't have a parameter list, simply check whether the
+        // first type is a subtype of the second.
         cs.addConstraint(ConstraintKind::Subtype,
                          openedType1,
                          openedType2,
                          locator);
-        break;
-
-      case CheckInput: {
-        // Check whether the first function type's input is a subtype of the
-        // second type's inputs, i.e., can we forward the arguments?
+      } else {
+        // Otherwise, check whether the first function type's input is a subtype
+        // of the second type's inputs, i.e., can we forward the arguments?
         auto funcTy1 = openedType1->castTo<FunctionType>();
         auto funcTy2 = openedType2->castTo<FunctionType>();
         auto params1 = funcTy1->getParams();
@@ -698,9 +677,6 @@ static bool isDeclAsSpecializedAs(TypeChecker &tc, DeclContext *dc,
         if (compareTrailingClosureParamsSeparately)
           if (!maybeAddSubtypeConstraint(params1.back(), params2.back()))
             knownNonSubtype = true;
-
-        break;
-      }
       }
 
       if (!knownNonSubtype) {

lib/Sema/CSSimplify.cpp

@@ -144,18 +144,8 @@ bool constraints::areConservativelyCompatibleArgumentLabels(
     return true;
   }
 
-
-  const AnyFunctionType *fTy;
-
-  if (auto fn = dyn_cast<AbstractFunctionDecl>(decl)) {
-    fTy = fn->getInterfaceType()->castTo<AnyFunctionType>();
-  } else if (auto subscript = dyn_cast<SubscriptDecl>(decl)) {
-    fTy = subscript->getInterfaceType()->castTo<AnyFunctionType>();
-  } else if (auto enumElement = dyn_cast<EnumElementDecl>(decl)) {
-    fTy = enumElement->getInterfaceType()->castTo<AnyFunctionType>();
-  } else {
+  if (!decl->hasParameterList())
     return true;
-  }
 
   SmallVector<AnyFunctionType::Param, 8> argInfos;
   for (auto argLabel : labels) {