[Sema] Adopt ArgumentList

Author: hamishknight

lib/Sema/ConstantnessSemaDiagnostics.cpp

@@ -119,7 +119,8 @@ static Expr *checkConstantness(Expr *expr) {
       continue;
     }
     if (BinaryExpr *binaryExpr = dyn_cast<BinaryExpr>(expr)) {
-      expressionsToCheck.push_back(binaryExpr->getArg());
+      expressionsToCheck.push_back(binaryExpr->getLHS());
+      expressionsToCheck.push_back(binaryExpr->getRHS());
       continue;
     }
     if (InjectIntoOptionalExpr *optionalExpr =
@@ -179,7 +180,8 @@ static Expr *checkConstantness(Expr *expr) {
 
     // If this is an enum case, check whether the arguments are constants.
     if (isa<EnumElementDecl>(calledValue)) {
-      expressionsToCheck.push_back(apply->getArg());
+      for (auto arg : *apply->getArgs())
+        expressionsToCheck.push_back(arg.getExpr());
       continue;
     }
 
@@ -196,7 +198,9 @@ static Expr *checkConstantness(Expr *expr) {
     // constants.
     if (!hasConstantEvaluableAttr(callee))
       return expr;
-    expressionsToCheck.push_back(apply->getArg());
+
+    for (auto arg : *apply->getArgs())
+      expressionsToCheck.push_back(arg.getExpr());
   }
   return nullptr;
 }
@@ -311,16 +315,9 @@ static void diagnoseConstantArgumentRequirementOfCall(const CallExpr *callExpr,
     return;
 
   // Check that the arguments at the constantArgumentIndices are constants.
-  Expr *argumentExpr = callExpr->getArg();
   SmallVector<Expr *, 4> arguments;
-  if (TupleExpr *tupleExpr = dyn_cast<TupleExpr>(argumentExpr)) {
-    auto elements = tupleExpr->getElements();
-    arguments.append(elements.begin(), elements.end());
-  } else if (ParenExpr *parenExpr = dyn_cast<ParenExpr>(argumentExpr)) {
-    arguments.push_back(parenExpr->getSubExpr());
-  } else {
-    arguments.push_back(argumentExpr);
-  }
+  for (auto arg : *callExpr->getArgs())
+    arguments.push_back(arg.getExpr());
 
   for (unsigned constantIndex : constantArgumentIndices) {
     assert(constantIndex < arguments.size() &&

lib/Sema/TypeCheckAttr.cpp

@@ -1903,7 +1903,9 @@ synthesizeMainBody(AbstractFunctionDecl *fn, void *arg) {
                                                       DeclNameLoc(),
                                                       /*implicit=*/true);
     funcExpr->setType(runner->getInterfaceType());
-    auto *callExpr = CallExpr::createImplicit(context, funcExpr, memberRefExpr, {});
+    auto *argList =
+        ArgumentList::forImplicitUnlabeled(context, {memberRefExpr});
+    auto *callExpr = CallExpr::createImplicit(context, funcExpr, argList);
     returnedExpr = callExpr;
   } else if (mainFunction->hasThrows()) {
     auto *tryExpr = new (context) TryExpr(
@@ -3044,9 +3046,9 @@ void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
     }
 
     // Diagnose and ignore arguments.
-    if (attr->getArg()) {
+    if (attr->hasArgs()) {
       diagnose(attr->getLocation(), diag::result_builder_arguments)
-        .highlight(attr->getArg()->getSourceRange());
+        .highlight(attr->getArgs()->getSourceRange());
     }
 
     // Complain if this isn't the primary result-builder attribute.

lib/Sema/TypeCheckAvailability.cpp

@@ -1889,11 +1889,11 @@ static void fixItAvailableAttrRename(InFlightDiagnostic &diag,
     SourceLoc removeRangeStart;
     SourceLoc removeRangeEnd;
 
-    auto *argExpr = CE->getArg();
-    auto argList = getOriginalArgumentList(argExpr);
+    auto *argList = CE->getArgs();
+    auto originalArgs = argList->getOriginalArguments();
 
-    size_t numElementsWithinParens = argList.args.size();
-    numElementsWithinParens -= argList.getNumTrailingClosures();
+    size_t numElementsWithinParens = originalArgs.size();
+    numElementsWithinParens -= originalArgs.getNumTrailingClosures();
     if (selfIndex >= numElementsWithinParens)
       return;
 
@@ -1904,48 +1904,48 @@ static void fixItAvailableAttrRename(InFlightDiagnostic &diag,
       if (numElementsWithinParens != 2)
         return;
     } else {
-      if (parsed.ArgumentLabels.size() != argList.args.size() - 1)
+      if (parsed.ArgumentLabels.size() != originalArgs.size() - 1)
         return;
     }
 
-    selfExpr = argList.args[selfIndex];
+    selfExpr = originalArgs[selfIndex].getExpr();
 
     if (selfIndex + 1 == numElementsWithinParens) {
       if (selfIndex > 0) {
         // Remove from the previous comma to the close-paren (half-open).
-        removeRangeStart = argList.args[selfIndex-1]->getEndLoc();
+        removeRangeStart = originalArgs[selfIndex - 1].getExpr()->getEndLoc();
         removeRangeStart = Lexer::getLocForEndOfToken(sourceMgr,
                                                       removeRangeStart);
       } else {
         // Remove from after the open paren to the close paren (half-open).
-        removeRangeStart = Lexer::getLocForEndOfToken(sourceMgr,
-                                                      argExpr->getStartLoc());
+        removeRangeStart =
+            Lexer::getLocForEndOfToken(sourceMgr, argList->getStartLoc());
       }
 
       // Prefer the r-paren location, so that we get the right behavior when
       // there's a trailing closure, but handle some implicit cases too.
-      removeRangeEnd = argList.rParenLoc;
+      removeRangeEnd = argList->getRParenLoc();
       if (removeRangeEnd.isInvalid())
-        removeRangeEnd = argExpr->getEndLoc();
+        removeRangeEnd = argList->getEndLoc();
 
     } else {
       // Remove from the label to the start of the next argument (half-open).
-      SourceLoc labelLoc = argList.labelLocs[selfIndex];
+      SourceLoc labelLoc = originalArgs[selfIndex].getLabelLoc();
       if (labelLoc.isValid())
         removeRangeStart = labelLoc;
       else
         removeRangeStart = selfExpr->getStartLoc();
 
-      SourceLoc nextLabelLoc = argList.labelLocs[selfIndex + 1];
+      SourceLoc nextLabelLoc = originalArgs[selfIndex + 1].getLabelLoc();
       if (nextLabelLoc.isValid())
         removeRangeEnd = nextLabelLoc;
       else
-        removeRangeEnd = argList.args[selfIndex + 1]->getStartLoc();
+        removeRangeEnd = originalArgs[selfIndex + 1].getExpr()->getStartLoc();
     }
 
     // Avoid later argument label fix-its for this argument.
     if (!parsed.isPropertyAccessor()) {
-      Identifier oldLabel = argList.labels[selfIndex];
+      Identifier oldLabel = originalArgs[selfIndex].getLabel();
       StringRef oldLabelStr;
       if (!oldLabel.empty())
         oldLabelStr = oldLabel.str();
@@ -2046,7 +2046,7 @@ static void fixItAvailableAttrRename(InFlightDiagnostic &diag,
 
       // Renaming from SubscriptExpr to CallExpr. Insert function name and
       // replace square brackets with parens.
-      diag.fixItReplace(SE->getIndex()->getStartLoc(),
+      diag.fixItReplace(SE->getArgs()->getStartLoc(),
                         ("." + baseReplace.str() + "(").str());
       diag.fixItReplace(SE->getEndLoc(), ")");
     } else {
@@ -2060,45 +2060,37 @@ static void fixItAvailableAttrRename(InFlightDiagnostic &diag,
     }
   }
 
-  if (!call)
-    return;
-
-  Expr *argExpr;
-  if (auto *CE = dyn_cast<CallExpr>(call))
-    argExpr = CE->getArg();
-  else if (auto *SE = dyn_cast<SubscriptExpr>(call))
-    argExpr = SE->getIndex();
-  else
+  if (!call || !call->getArgs())
     return;
 
-  auto argList = getOriginalArgumentList(argExpr);
+  auto *argList = call->getArgs();
+  auto originalArgs = argList->getOriginalArguments();
 
   if (parsed.IsGetter) {
-    diag.fixItRemove(argExpr->getSourceRange());
+    diag.fixItRemove(argList->getSourceRange());
     return;
   }
 
   if (parsed.IsSetter) {
     const Expr *newValueExpr = nullptr;
 
-    if (argList.args.size() >= 1) {
+    if (originalArgs.size() >= 1) {
       size_t newValueIndex = 0;
       if (parsed.isInstanceMember()) {
         assert(parsed.SelfIndex.getValue() == 0 ||
                parsed.SelfIndex.getValue() == 1);
         newValueIndex = !parsed.SelfIndex.getValue();
       }
-      newValueExpr = argList.args[newValueIndex];
+      newValueExpr = originalArgs[newValueIndex].getExpr();
     } else {
-      newValueExpr = argList.args[0];
+      newValueExpr = originalArgs[0].getExpr();
     }
 
-    diag.fixItReplaceChars(argExpr->getStartLoc(), newValueExpr->getStartLoc(),
+    diag.fixItReplaceChars(argList->getStartLoc(), newValueExpr->getStartLoc(),
                            " = ");
-    diag.fixItRemoveChars(Lexer::getLocForEndOfToken(sourceMgr,
-                                                     newValueExpr->getEndLoc()),
-                          Lexer::getLocForEndOfToken(sourceMgr,
-                                                     argExpr->getEndLoc()));
+    diag.fixItRemoveChars(
+        Lexer::getLocForEndOfToken(sourceMgr, newValueExpr->getEndLoc()),
+        Lexer::getLocForEndOfToken(sourceMgr, argList->getEndLoc()));
     return;
   }
 
@@ -2162,28 +2154,23 @@ static void fixItAvailableAttrRename(InFlightDiagnostic &diag,
     return false;
   };
 
-  if (auto *parenExpr = dyn_cast<ParenExpr>(argExpr)) {
-    if (updateLabelsForArg(parenExpr->getSubExpr()))
+  for (auto arg : *argList) {
+    if (updateLabelsForArg(arg.getExpr()))
       return;
-  } else {
-    for (auto *arg : cast<TupleExpr>(argExpr)->getElements()) {
-      if (updateLabelsForArg(arg))
-        return;
-    }
   }
 
-  if (argumentLabelIDs.size() != argList.args.size()) {
+  if (argumentLabelIDs.size() != originalArgs.size()) {
     // Mismatched lengths; give up.
     return;
   }
 
   // If any of the argument labels are mismatched, perform label correction.
-  for (auto i : indices(argList.args)) {
+  for (auto i : indices(originalArgs)) {
     // The argument label of an unlabeled trailing closure is ignored.
-    if (argList.isUnlabeledTrailingClosureIdx(i))
+    if (originalArgs.isUnlabeledTrailingClosureIndex(i))
       continue;
-    if (argumentLabelIDs[i] != argList.labels[i]) {
-      diagnoseArgumentLabelError(ctx, argExpr, argumentLabelIDs,
+    if (argumentLabelIDs[i] != originalArgs[i].getLabel()) {
+      diagnoseArgumentLabelError(ctx, argList, argumentLabelIDs,
                                  parsed.IsSubscript, &diag);
       return;
     }
@@ -3172,8 +3159,8 @@ ExprAvailabilityWalker::diagnoseIncDecRemoval(const ValueDecl *D, SourceRange R,
     // Otherwise, it must be an index type.  Rewrite to:
     // "lvalue = lvalue.successor()".
     auto &SM = Context.SourceMgr;
-    auto CSR = Lexer::getCharSourceRangeFromSourceRange(SM,
-                                         call->getArg()->getSourceRange());
+    auto CSR = Lexer::getCharSourceRangeFromSourceRange(
+        SM, call->getArgs()->getSourceRange());
     replacement = " = " + SM.extractText(CSR).str();
     replacement += isInc ? ".successor()" : ".predecessor()";
   }
@@ -3191,7 +3178,7 @@ ExprAvailabilityWalker::diagnoseIncDecRemoval(const ValueDecl *D, SourceRange R,
     if (isa<PrefixUnaryExpr>(call)) {
       // Prefix: remove the ++ or --.
       diag.fixItRemove(call->getFn()->getSourceRange());
-      diag.fixItInsertAfter(call->getArg()->getEndLoc(), replacement);
+      diag.fixItInsertAfter(call->getArgs()->getEndLoc(), replacement);
     } else {
       // Postfix: replace the ++ or --.
       diag.fixItReplace(call->getFn()->getSourceRange(), replacement);
@@ -3227,8 +3214,9 @@ ExprAvailabilityWalker::diagnoseMemoryLayoutMigration(const ValueDecl *D,
   if (Property.empty())
     return false;
 
-  auto args = dyn_cast<ParenExpr>(call->getArg());
-  if (!args)
+  auto *args = call->getArgs();
+  auto *subject = args->getUnlabeledUnaryExpr();
+  if (!subject)
     return false;
 
   DeclName Name;
@@ -3242,8 +3230,6 @@ ExprAvailabilityWalker::diagnoseMemoryLayoutMigration(const ValueDecl *D,
           Name, true, "", EncodedMessage.Message);
   diag.highlight(R);
 
-  auto subject = args->getSubExpr();
-
   StringRef Prefix = "MemoryLayout<";
   StringRef Suffix = ">.";