Change from using the @_inheritedDefaultValue attribute to mark parameters with an inherited default argument to using '= super'

Author: Nathan Hawes

include/swift/AST/Attr.def

@@ -396,9 +396,6 @@ SIMPLE_DECL_ATTR(_implementationOnly, ImplementationOnly,
 DECL_ATTR(_custom, Custom,
   OnAnyDecl | UserInaccessible,
   85)
-SIMPLE_DECL_ATTR(_inheritedDefaultValue, InheritedDefaultValue,
-  OnParam | UserInaccessible,
-  86)
 
 #undef TYPE_ATTR
 #undef DECL_ATTR_ALIAS

include/swift/AST/DiagnosticsSema.def

@@ -1282,13 +1282,14 @@ WARNING(expr_dynamic_lookup_swift3_objc_inference,none,
         (DescriptiveDeclKind, DeclName, Identifier))
 
 ERROR(inherited_default_value_not_on_constructor_param,none,
-      "@_inheritedDefaultValue is only valid on parameter declarations of initializers", ())
+      "default value inheritance via 'super' is only valid for initializer "
+      "parameters", ())
 ERROR(corresponding_param_not_defaulted,none,
-      "@_inheritedDefaultValue requires that the corresponding parameter of "
-      "the overridden initializer has a default value", ())
+      "default value inheritance via 'super' requires that the corresponding "
+      "parameter of the overridden initializer has a default value", ())
 ERROR(inherited_default_value_used_in_non_overriding_constructor,none,
-      "@_inheritedDefaultValue can only be used on the parameters of "
-      "overriding initializers", ())
+      "default value inheritance via 'super' can only be used on the "
+      "parameters of overriding initializers", ())
 
 // Alignment attribute
 ERROR(alignment_not_power_of_two,none,

include/swift/Parse/Parser.h

@@ -1143,6 +1143,9 @@ class Parser {
 
     /// The default argument for this parameter.
     Expr *DefaultArg = nullptr;
+
+    /// True if this parameter inherits a default argument via '= super'
+    bool hasInheritedDefaultArg = false;
 
     /// True if we emitted a parse error about this parameter.
     bool isInvalid = false;

lib/AST/ASTPrinter.cpp

@@ -2510,12 +2510,6 @@ void PrintAST::printOneParameter(const ParamDecl *param,
     Printer.printStructurePost(PrintStructureKind::FunctionParameter, param);
   };
 
-  bool inheritsDefault =
-      param->getDefaultArgumentKind() == DefaultArgumentKind::Inherited;
-  if (inheritsDefault) {
-    Printer << "@_inheritedDefaultValue ";
-  }
-
   auto printArgName = [&]() {
     // Print argument name.
     auto ArgName = param->getArgumentName();
@@ -2594,7 +2588,7 @@ void PrintAST::printOneParameter(const ParamDecl *param,
   if (param->isVariadic())
     Printer << "...";
 
-  if (param->isDefaultArgument() && !inheritsDefault) {
+  if (param->isDefaultArgument()) {
     SmallString<128> scratch;
     auto defaultArgStr = param->getDefaultValueStringRepresentation(scratch);
 

lib/AST/Decl.cpp

@@ -5403,6 +5403,7 @@ ParamDecl::getDefaultValueStringRepresentation(
                                 var->getParentInitializer(),
                                 scratch);
   }
+  case DefaultArgumentKind::Inherited: return "super";
   case DefaultArgumentKind::File: return "#file";
   case DefaultArgumentKind::Line: return "#line";
   case DefaultArgumentKind::Column: return "#column";
@@ -5411,10 +5412,6 @@ ParamDecl::getDefaultValueStringRepresentation(
   case DefaultArgumentKind::NilLiteral: return "nil";
   case DefaultArgumentKind::EmptyArray: return "[]";
   case DefaultArgumentKind::EmptyDictionary: return "[:]";
-  case DefaultArgumentKind::Inherited:
-    // Inherited default values are set via the @_inheritedDefaultValue
-    // attribute, so should be printed in the attribute position
-    llvm_unreachable("inherted default should be printed as an attribute");
   }
   llvm_unreachable("unhandled kind");
 }

lib/Parse/ParsePattern.cpp

@@ -66,10 +66,22 @@ void Parser::DefaultArgumentInfo::setFunctionContext(
 
 static ParserStatus parseDefaultArgument(
     Parser &P, Parser::DefaultArgumentInfo *defaultArgs, unsigned argIndex,
-    Expr *&init, Parser::ParameterContextKind paramContext) {
+    Expr *&init, bool &hasInheritedDefaultArg,
+    Parser::ParameterContextKind paramContext) {
   SyntaxParsingContext DefaultArgContext(P.SyntaxContext,
                                          SyntaxKind::InitializerClause);
   SourceLoc equalLoc = P.consumeToken(tok::equal);
+  // Handle the special '= super' syntax for inherited default values in module
+  // interface files
+  if (P.SF.Kind == SourceFileKind::Interface) {
+    if (P.Tok.is(tok::kw_super) && P.peekToken().isAny(tok::comma, tok::r_paren)) {
+      hasInheritedDefaultArg = true;
+      P.consumeToken(tok::kw_super);
+      P.SyntaxContext->createNodeInPlace(SyntaxKind::SuperRefExpr);
+      defaultArgs->HasDefaultArgument = true;
+      return ParserStatus();
+    }
+  }
 
   // Enter a fresh default-argument context with a meaningless parent.
   // We'll change the parent to the function later after we've created
@@ -365,7 +377,9 @@ Parser::parseParameterClause(SourceLoc &leftParenLoc,
     if (Tok.is(tok::equal)) {
       SourceLoc EqualLoc = Tok.getLoc();
       status |= parseDefaultArgument(*this, defaultArgs, defaultArgIndex,
-                                     param.DefaultArg, paramContext);
+                                     param.DefaultArg,
+                                     param.hasInheritedDefaultArg,
+                                     paramContext);
 
       if (param.EllipsisLoc.isValid() && param.DefaultArg) {
         // The range of the complete default argument.
@@ -604,7 +618,7 @@ mapParsedParameters(Parser &parser,
     }
 
     assert (((!param.DefaultArg &&
-              !param.Attrs.hasAttribute<InheritedDefaultValueAttr>()) ||
+              !param.hasInheritedDefaultArg) ||
              paramContext == Parser::ParameterContextKind::Function ||
              paramContext == Parser::ParameterContextKind::Operator ||
              paramContext == Parser::ParameterContextKind::Initializer ||
@@ -616,7 +630,7 @@ mapParsedParameters(Parser &parser,
       DefaultArgumentKind kind = getDefaultArgKind(param.DefaultArg);
       result->setDefaultArgumentKind(kind);
       result->setDefaultValue(param.DefaultArg);
-    } else if (param.Attrs.hasAttribute<InheritedDefaultValueAttr>()) {
+    } else if (param.hasInheritedDefaultArg) {
       result->setDefaultArgumentKind(DefaultArgumentKind::Inherited);
     }
 

lib/Sema/TypeCheckAttr.cpp

@@ -126,7 +126,6 @@ class AttributeEarlyChecker : public AttributeVisitor<AttributeEarlyChecker> {
   IGNORED_ATTR(DynamicReplacement)
   IGNORED_ATTR(PrivateImport)
   IGNORED_ATTR(Custom)
-  IGNORED_ATTR(InheritedDefaultValue)
 #undef IGNORED_ATTR
 
   void visitAlignmentAttr(AlignmentAttr *attr) {
@@ -757,7 +756,6 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
     IGNORED_ATTR(ImplementationOnly)
     IGNORED_ATTR(ImplicitlyUnwrappedOptional)
     IGNORED_ATTR(Indirect)
-    IGNORED_ATTR(InheritedDefaultValue)
     IGNORED_ATTR(Inline)
     IGNORED_ATTR(Lazy)      // checked early.
     IGNORED_ATTR(LLDBDebuggerFunction)

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1298,7 +1298,6 @@ namespace  {
     UNINTERESTING_ATTR(Specialize)
     UNINTERESTING_ATTR(DynamicReplacement)
     UNINTERESTING_ATTR(PrivateImport)
-    UNINTERESTING_ATTR(InheritedDefaultValue)
 
     // These can't appear on overridable declarations.
     UNINTERESTING_ATTR(Prefix)

lib/Sema/TypeCheckStmt.cpp

@@ -1748,25 +1748,29 @@ getParamIndex(const ParameterList *paramList, const ParamDecl *decl) {
 
 static void
 checkInheritedDefaultValueRestrictions(TypeChecker &TC, ParamDecl *PD) {
-  auto *attr = PD->getAttrs().getAttribute<InheritedDefaultValueAttr>();
-  if (!attr)
+  if (PD->getDefaultArgumentKind() != DefaultArgumentKind::Inherited)
     return;
 
   auto *DC = PD->getInnermostDeclContext();
+  const SourceFile *SF = DC->getParentSourceFile();
+  if (!SF || SF->Kind != SourceFileKind::Interface)
+    return;
+
   if (!isa<ConstructorDecl>(DC)) {
-    TC.diagnose(attr->getLocation(),
+    TC.diagnose(PD->getLoc(),
                 diag::inherited_default_value_not_on_constructor_param);
-    attr->setInvalid();
     return;
   }
 
   // Check the matching parameter of an overriden decl has a default value
   auto ctor = cast<ConstructorDecl>(DC);
   Optional<unsigned> idx = getParamIndex(ctor->getParameters(), PD);
+  bool foundOverriden = false;
   assert(idx && "containing decl does not contain param?");
   for (auto overridden = ctor->getOverriddenDecl();
        overridden != nullptr;
        overridden = overridden->getOverriddenDecl()) {
+    foundOverriden = true;
     auto equivalentParam = overridden->getParameters()->get(*idx);
     assert(equivalentParam && "inherited decl mismatched arguments?");
 
@@ -1777,18 +1781,23 @@ checkInheritedDefaultValueRestrictions(TypeChecker &TC, ParamDecl *PD) {
 
     // If it doesn't have a default value, diagnose it
     if (equivalentParam->getDefaultArgumentKind() == DefaultArgumentKind::None) {
-      TC.diagnose(attr->getLocation(),
+      TC.diagnose(PD->getLoc(),
                   diag::corresponding_param_not_defaulted);
-      attr->setInvalid();
     }
     // We found a match: it's valid
     return;
   }
 
-  // used on a param of a non-overriding initializer
-  TC.diagnose(attr->getLocation(),
+  // Used with a param of a non-overriding initializer, or one where the
+  // corresponding param in the overridden decl was also inherited but *it*
+  // didn't override anything. Diagnose the first case and ignore the second.
+  // The second will be diagnosed when checking the default args of the
+  // overridden declaration.
+  if (foundOverriden)
+    return;
+
+  TC.diagnose(PD->getLoc(),
               diag::inherited_default_value_used_in_non_overriding_constructor);
-  attr->setInvalid();
 }
 
 /// Check the default arguments that occur within this pattern.