Sema: Subscript default arguments

slavapestov · slavapestov · commit 6bb36b5c01c8 · 2019-04-02T20:37:01.000-04:00
Fixes <https://bugs.swift.org/browse/SR-6118>.
diff --git a/include/swift/AST/DiagnosticsParse.def b/include/swift/AST/DiagnosticsParse.def
@@ -821,8 +821,6 @@ ERROR(untyped_pattern_ellipsis,none,
       "'...' cannot be applied to a subpattern which is not explicitly typed", ())
 ERROR(no_default_arg_closure,none,
       "default arguments are not allowed in closures", ())
-ERROR(no_default_arg_subscript,none,
-      "default arguments are not allowed in subscripts", ())
 ERROR(no_default_arg_curried,none,
       "default arguments are not allowed in curried parameter lists", ())
 ERROR(var_pattern_in_var,none,
diff --git a/include/swift/Parse/Parser.h b/include/swift/Parse/Parser.h
@@ -1098,8 +1098,8 @@ class Parser {
     /// all the arguments, not just those that have default arguments.
     unsigned claimNextIndex() { return NextIndex++; }
 
-    /// Set the parsed context for all the initializers to the given
-    /// function.
+    /// Set the parsed context of all default argument initializers to
+    /// the given function, enum case or subscript.
     void setFunctionContext(DeclContext *DC, ParameterList *paramList);
     
     DefaultArgumentInfo() {
diff --git a/lib/AST/ASTVerifier.cpp b/lib/AST/ASTVerifier.cpp
@@ -761,6 +761,7 @@ class Verifier : public ASTWalker {
     FUNCTION_LIKE(DestructorDecl)
     FUNCTION_LIKE(FuncDecl)
     FUNCTION_LIKE(EnumElementDecl)
+    FUNCTION_LIKE(SubscriptDecl)
     SCOPE_LIKE(NominalTypeDecl)
     SCOPE_LIKE(ExtensionDecl)
 
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -5551,8 +5551,10 @@ const ParamDecl *swift::getParameterAt(ValueDecl *source, unsigned index) {
   const ParameterList *paramList;
   if (auto *AFD = dyn_cast<AbstractFunctionDecl>(source)) {
     paramList = AFD->getParameters();
+  } else if (auto *EED = dyn_cast<EnumElementDecl>(source)) {
+    paramList = EED->getParameterList();
   } else {
-    paramList = cast<EnumElementDecl>(source)->getParameterList();
+    paramList = cast<SubscriptDecl>(source)->getIndices();
   }
 
   return paramList->get(index);
diff --git a/lib/AST/DeclContext.cpp b/lib/AST/DeclContext.cpp
@@ -318,8 +318,10 @@ ResilienceExpansion DeclContext::getResilienceExpansion() const {
       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<EnumElementDecl>(dc);
+        VD = cast<SubscriptDecl>(dc);
       }
 
       auto access =
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
@@ -6364,10 +6364,11 @@ Parser::parseDeclSubscript(ParseDeclOptions Flags,
     return makeParserCodeCompletionStatus();
 
   // Parse the parameter list.
+  DefaultArgumentInfo DefaultArgs;
   SmallVector<Identifier, 4> argumentNames;
   ParserResult<ParameterList> Indices
     = parseSingleParameterClause(ParameterContextKind::Subscript,
-                                 &argumentNames);
+                                 &argumentNames, &DefaultArgs);
   Status |= Indices;
 
   SignatureHasCodeCompletion |= Indices.hasCodeCompletion();
@@ -6419,6 +6420,8 @@ Parser::parseDeclSubscript(ParseDeclOptions Flags,
                                                 nullptr);
   Subscript->getAttrs() = Attributes;
 
+  DefaultArgs.setFunctionContext(Subscript, Subscript->getIndices());
+
   // Parse a 'where' clause if present, adding it to our GenericParamList.
   if (Tok.is(tok::kw_where)) {
     ContextChange CC(*this, Subscript);
diff --git a/lib/Parse/ParsePattern.cpp b/lib/Parse/ParsePattern.cpp
@@ -92,13 +92,11 @@ static ParserStatus parseDefaultArgument(
   case Parser::ParameterContextKind::Operator:
   case Parser::ParameterContextKind::Initializer:
   case Parser::ParameterContextKind::EnumElement:
+  case Parser::ParameterContextKind::Subscript:
     break;
   case Parser::ParameterContextKind::Closure:
     diagID = diag::no_default_arg_closure;
     break;
-  case Parser::ParameterContextKind::Subscript:
-    diagID = diag::no_default_arg_subscript;
-    break;
   case Parser::ParameterContextKind::Curried:
     diagID = diag::no_default_arg_curried;
     break;
@@ -609,7 +607,8 @@ mapParsedParameters(Parser &parser,
       assert((paramContext == Parser::ParameterContextKind::Function ||
               paramContext == Parser::ParameterContextKind::Operator ||
               paramContext == Parser::ParameterContextKind::Initializer ||
-              paramContext == Parser::ParameterContextKind::EnumElement) &&
+              paramContext == Parser::ParameterContextKind::EnumElement ||
+              paramContext == Parser::ParameterContextKind::Subscript) &&
              "Default arguments are only permitted on the first param clause");
       DefaultArgumentKind kind = getDefaultArgKind(param.DefaultArg);
       result->setDefaultArgumentKind(kind);
diff --git a/lib/SIL/TypeLowering.cpp b/lib/SIL/TypeLowering.cpp
@@ -1755,9 +1755,14 @@ static CanAnyFunctionType getDefaultArgGeneratorInterfaceType(
   }
 
   // Get the generic signature from the surrounding context.
-  auto funcInfo = TC.getConstantInfo(SILDeclRef(VD));
-  return CanAnyFunctionType::get(funcInfo.FormalType.getOptGenericSignature(),
-                                 {}, canResultTy);
+  CanGenericSignature sig;
+  if (auto *afd = dyn_cast<AbstractFunctionDecl>(VD)) {
+    auto funcInfo = TC.getConstantInfo(SILDeclRef(VD));
+    sig = funcInfo.FormalType.getOptGenericSignature();
+  } else {
+    sig = TC.getEffectiveGenericSignature(DC);
+  }
+  return CanAnyFunctionType::get(sig, {}, canResultTy);
 }
 
 /// Get the type of a stored property initializer, () -> T.
@@ -1940,7 +1945,8 @@ CanAnyFunctionType TypeConverter::makeConstantInterfaceType(SILDeclRef c) {
     return getGlobalAccessorType(var->getInterfaceType()->getCanonicalType());
   }
   case SILDeclRef::Kind::DefaultArgGenerator:
-    return getDefaultArgGeneratorInterfaceType(*this, vd, vd->getDeclContext(),
+    return getDefaultArgGeneratorInterfaceType(*this, vd,
+                                               vd->getInnermostDeclContext(),
                                                c.defaultArgIndex);
   case SILDeclRef::Kind::StoredPropertyInitializer:
     return getStoredPropertyInitializerInterfaceType(*this,
@@ -1995,7 +2001,10 @@ TypeConverter::getConstantGenericEnvironment(SILDeclRef c) {
     return cast<ClassDecl>(vd)->getGenericEnvironmentOfContext();
   case SILDeclRef::Kind::DefaultArgGenerator:
     // Use the generic environment of the original function.
-    return getConstantGenericEnvironment(SILDeclRef(c.getDecl()));
+    if (auto *afd = dyn_cast<AbstractFunctionDecl>(c.getDecl()))
+      return getConstantGenericEnvironment(SILDeclRef(c.getDecl()));
+    return c.getDecl()->getInnermostDeclContext()
+                      ->getGenericEnvironmentOfContext();
   case SILDeclRef::Kind::StoredPropertyInitializer:
     // Use the generic environment of the containing type.
     return c.getDecl()->getDeclContext()->getGenericEnvironmentOfContext();
diff --git a/lib/SILGen/SILGenFunction.cpp b/lib/SILGen/SILGenFunction.cpp
@@ -100,6 +100,9 @@ DeclName SILGenModule::getMagicFunctionName(DeclContext *dc) {
   if (auto EED = dyn_cast<EnumElementDecl>(dc)) {
     return EED->getFullName();
   }
+  if (auto SD = dyn_cast<SubscriptDecl>(dc)) {
+    return SD->getFullName();
+  }
   llvm_unreachable("unexpected #function context");
 }
 
diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp
@@ -1044,6 +1044,12 @@ class SILGenType : public TypeMemberVisitor<SILGenType> {
     visitAbstractStorageDecl(vd);
   }
 
+  void visitSubscriptDecl(SubscriptDecl *sd) {
+    SGM.emitDefaultArgGenerators(sd, sd->getIndices());
+
+    visitAbstractStorageDecl(sd);
+  }
+
   void visitAbstractStorageDecl(AbstractStorageDecl *asd) {
     // FIXME: Default implementations in protocols.
     if (asd->isObjC() && !isa<ProtocolDecl>(asd->getDeclContext()))
@@ -1154,6 +1160,11 @@ class SILGenExtension : public TypeMemberVisitor<SILGenExtension> {
     visitAbstractStorageDecl(vd);
   }
 
+  void visitSubscriptDecl(SubscriptDecl *sd) {
+    SGM.emitDefaultArgGenerators(sd, sd->getIndices());
+    visitAbstractStorageDecl(sd);
+  }
+
   void visitEnumCaseDecl(EnumCaseDecl *ecd) {}
   void visitEnumElementDecl(EnumElementDecl *ed) {
     llvm_unreachable("enum elements aren't allowed in extensions");
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -5290,8 +5290,7 @@ Expr *ExprRewriter::coerceCallArguments(
     findCalleeDeclRef(cs, solution, cs.getConstraintLocator(locator));
 
   // Determine whether this application has curried self.
-  bool skipCurriedSelf = apply ? hasCurriedSelf(cs, callee, apply) : false;
-
+  bool skipCurriedSelf = apply ? hasCurriedSelf(cs, callee, apply) : true;
   // Determine the parameter bindings.
   SmallBitVector defaultMap
     = computeDefaultMap(params, callee.getDecl(), skipCurriedSelf);
diff --git a/lib/Sema/CSDiag.cpp b/lib/Sema/CSDiag.cpp
@@ -161,6 +161,16 @@ void constraints::simplifyLocator(Expr *&anchor,
         continue;
       }
 
+      if (auto subscriptExpr = dyn_cast<SubscriptExpr>(anchor)) {
+        // The target anchor is the subscript.
+        targetAnchor = subscriptExpr;
+        targetPath.clear();
+
+        anchor = subscriptExpr->getIndex();
+        path = path.slice(1);
+        continue;
+      }
+
       if (auto objectLiteralExpr = dyn_cast<ObjectLiteralExpr>(anchor)) {
         targetAnchor = nullptr;
         targetPath.clear();
@@ -196,6 +206,17 @@ void constraints::simplifyLocator(Expr *&anchor,
         continue;
       }
 
+      // The subscript itself is the function.
+      if (auto subscriptExpr = dyn_cast<SubscriptExpr>(anchor)) {
+        // No additional target locator information.
+        targetAnchor = nullptr;
+        targetPath.clear();
+
+        anchor = subscriptExpr;
+        path = path.slice(1);
+        continue;
+      }
+
       // The unresolved member itself is the function.
       if (auto unresolvedMember = dyn_cast<UnresolvedMemberExpr>(anchor)) {
         if (unresolvedMember->getArgument()) {
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -127,7 +127,7 @@ bool constraints::areConservativelyCompatibleArgumentLabels(
   // we can get an unapplied declaration reference back.
   bool hasCurriedSelf;
   if (isa<SubscriptDecl>(decl)) {
-    hasCurriedSelf = false;
+    hasCurriedSelf = true;
   } else if (!baseType || baseType->is<ModuleType>()) {
     hasCurriedSelf = false;
   } else if (baseType->is<AnyMetatypeType>() && decl->isInstanceMember()) {
@@ -146,7 +146,6 @@ bool constraints::areConservativelyCompatibleArgumentLabels(
   if (auto fn = dyn_cast<AbstractFunctionDecl>(decl)) {
     fTy = fn->getInterfaceType()->castTo<AnyFunctionType>();
   } else if (auto subscript = dyn_cast<SubscriptDecl>(decl)) {
-    assert(!hasCurriedSelf && "Subscripts never have curried 'self'");
     fTy = subscript->getInterfaceType()->castTo<AnyFunctionType>();
   } else if (auto enumElement = dyn_cast<EnumElementDecl>(decl)) {
     fTy = enumElement->getInterfaceType()->castTo<AnyFunctionType>();
@@ -160,7 +159,7 @@ bool constraints::areConservativelyCompatibleArgumentLabels(
   }
 
   const AnyFunctionType *levelTy = fTy;
-  if (hasCurriedSelf) {
+  if (hasCurriedSelf && !isa<SubscriptDecl>(decl)) {
     levelTy = levelTy->getResult()->getAs<AnyFunctionType>();
     assert(levelTy && "Parameter list curry level does not match type");
   }
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -2416,6 +2416,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     if (SD->getAttrs().hasAttribute<DynamicReplacementAttr>()) {
       TC.checkDynamicReplacementAttribute(SD);
     }
+
+    TC.checkDefaultArguments(SD->getIndices(), SD);
   }
 
   void visitTypeAliasDecl(TypeAliasDecl *TAD) {
diff --git a/test/ParseableInterface/default-args.swift b/test/ParseableInterface/default-args.swift
@@ -0,0 +1,30 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-frontend -emit-module -o %t/Test~partial.swiftmodule -module-name Test -primary-file %s
+// RUN: %target-swift-frontend -merge-modules -emit-module -o %t/Test.swiftmodule %t/Test~partial.swiftmodule
+// RUN: %target-swift-ide-test -print-module -module-to-print=Test -source-filename=x -I %t | %FileCheck %s
+
+// RUN: %target-swift-frontend -typecheck -emit-parseable-module-interface-path %t.swiftinterface -enable-library-evolution %s
+// RUN: %FileCheck %s < %t.swiftinterface
+
+public enum Enum {
+  // CHECK: case pie(filling: String = "apple")
+  case pie(filling: String = "apple")
+}
+
+public struct HasSubscript {
+  // CHECK: subscript(x: Int = 0) -> Int {
+  public subscript(x: Int = 0) -> Int { return 0 }
+}
+
+// CHECK: func hasClosureDefaultArg(_ x: () -> Void = {
+// CHECK-NEXT: })
+public func hasClosureDefaultArg(_ x: () -> Void = {
+}) {
+}
+
+// CHECK: func hasMagicDefaultArgs(_ f: String = #file, _ fu: String = #function, _ l: Int = #line)
+public func hasMagicDefaultArgs(_ f: String = #file, _ fu: String = #function, _ l: Int = #line) {}
+
+// CHECK: func hasSimpleDefaultArgs(_ x: Int = 0, b: Int = 1)
+public func hasSimpleDefaultArgs(_ x: Int = 0, b: Int = 1) {
+}
diff --git a/test/ParseableInterface/if-configs.swift b/test/ParseableInterface/if-configs.swift
@@ -6,12 +6,6 @@
 // RUN: %target-swift-frontend -typecheck -emit-parseable-module-interface-path %t.swiftinterface -enable-library-evolution %s
 // RUN: %FileCheck %s < %t.swiftinterface
 
-// CHECK: func hasClosureDefaultArg(_ x: () -> Void = {
-// CHECK-NEXT: })
-public func hasClosureDefaultArg(_ x: () -> Void = {
-}) {
-}
-
 // CHECK: func hasClosureDefaultArgWithComplexNestedPoundIfs(_ x: () -> Void = {
 // CHECK-NOT: #if NOT_PROVIDED
 // CHECK-NOT: print("should not exist")
@@ -115,7 +109,3 @@ public func hasClosureDefaultArgWithSinglePoundIf(_ x: () -> Void = {
   #endif
 }) {
 }
-
-// CHECK: func hasSimpleDefaultArgs(_ x: Int = 0, b: Int = 1)
-public func hasSimpleDefaultArgs(_ x: Int = 0, b: Int = 1) {
-}
diff --git a/test/SILGen/subscript_default_arguments.swift b/test/SILGen/subscript_default_arguments.swift
diff --git a/test/decl/func/default-values-swift4.swift b/test/decl/func/default-values-swift4.swift
diff --git a/test/decl/subscript/subscripting.swift b/test/decl/subscript/subscripting.swift

Original file line number	Diff line number	Diff line change
`@@ -100,6 +100,9 @@ DeclName SILGenModule::getMagicFunctionName(DeclContext *dc) {`
`100`	`100`	`if (auto EED = dyn_cast<EnumElementDecl>(dc)) {`
`101`	`101`	`return EED->getFullName();`
`102`	`102`	`}`
	`103`	`+ if (auto SD = dyn_cast<SubscriptDecl>(dc)) {`
	`104`	`+ return SD->getFullName();`
	`105`	`+ }`
`103`	`106`	`llvm_unreachable("unexpected #function context");`
`104`	`107`	`}`
`105`	`108`