[AST] Carry AST names through call expressions.

DougGregor · DougGregor · commit b40c89d4c677 · 2016-07-26T11:23:57.000-07:00
diff --git a/include/swift/AST/Expr.h b/include/swift/AST/Expr.h
@@ -696,6 +696,21 @@ class TrailingCallArguments
     return { this->template getTrailingObjects<Identifier>(),
              asDerived().getNumArguments() };
   }
+
+  /// Retrieve the buffer containing the argument label locations.
+  ArrayRef<SourceLoc> getArgumentLabelLocs() const {
+    if (!asDerived().hasArgumentLabelLocs())
+      return { };
+    
+    return { this->template getTrailingObjects<SourceLoc>(),
+             asDerived().getNumArguments() };
+  }
+
+  /// Retrieve the location of the ith argument label.
+  SourceLoc getArgumentLabelLoc(unsigned i) const {
+    auto locs = getArgumentLabelLocs();
+    return i < locs.size() ? locs[i] : SourceLoc();
+  }
 };
 
 /// ErrorExpr - Represents a semantically erroneous subexpression in the AST,
@@ -1656,14 +1671,6 @@ class UnresolvedMemberExpr final
                        bool implicit);
 
 public:
-  /// Create a new unresolved member expression.
-  ///
-  /// Note: do not add new callers for this entry point; use the entry points
-  /// that take separate arguments.
-  static UnresolvedMemberExpr *create(ASTContext &ctx, SourceLoc dotLoc,
-                                      DeclNameLoc nameLoc, DeclName name,
-                                      Expr *arg, bool implicit);
-
   /// Create a new unresolved member expression with no arguments.
   static UnresolvedMemberExpr *create(ASTContext &ctx, SourceLoc dotLoc,
                                       DeclNameLoc nameLoc, DeclName name,
@@ -3535,9 +3542,11 @@ class CallExpr final : public ApplyExpr,
 public:
   /// Create a new call expression.
   ///
-  /// Note: prefer to use the second entry point, which separates out
-  /// arguments/labels/etc.
+  /// Note: prefer to use the entry points that separate out the arguments.
   static CallExpr *create(ASTContext &ctx, Expr *fn, Expr *arg,
+                          ArrayRef<Identifier> argLabels,
+                          ArrayRef<SourceLoc> argLabelLocs,
+                          bool hasTrailingClosure,
                           bool implicit, Type type = Type());
 
   /// Create a new implicit call expression without any source-location
diff --git a/include/swift/Parse/Parser.h b/include/swift/Parse/Parser.h
@@ -1191,7 +1191,7 @@ class Parser {
                              SourceLoc &rightLoc,
                              Expr *&trailingClosure);
 
-  ParserResult<Expr> parseTrailingClosure(SourceRange callee);
+  ParserResult<Expr> parseTrailingClosure(SourceRange calleeRange);
 
   // NOTE: used only for legacy support for old object literal syntax.
   // Will be removed in the future.
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
@@ -1126,6 +1126,12 @@ static Expr *packSingleArgument(
       return arg;
     }
 
+    // Make sure we have argument labels.
+    if (argLabels.empty()) {
+      argLabelsScratch.assign(args.size(), Identifier());
+      argLabels = argLabelsScratch;
+    }
+
     // Construct the argument tuple.
     if (argLabels.empty() && !args.empty()) {
       argLabelsScratch.assign(args.size(), Identifier());
@@ -1574,31 +1580,6 @@ UnresolvedMemberExpr::UnresolvedMemberExpr(SourceLoc dotLoc,
   initializeCallArguments(argLabels, argLabelLocs, hasTrailingClosure);
 }
 
-UnresolvedMemberExpr *UnresolvedMemberExpr::create(ASTContext &ctx,
-                                                   SourceLoc dotLoc,
-                                                   DeclNameLoc nameLoc,
-                                                   DeclName name,
-                                                   Expr *arg, bool implicit) {
-  // Inspect the argument to dig out the argument labels, their location, and
-  // whether there is a trailing closure.
-  SmallVector<Identifier, 4> argLabelsScratch;
-  SmallVector<SourceLoc, 4> argLabelLocs;
-  bool hasTrailingClosure = false;
-  ArrayRef<Identifier> argLabels;
-  if (arg) {
-    argLabels = getArgumentLabelsFromArgument(arg, argLabelsScratch,
-                                              &argLabelLocs,
-                                              &hasTrailingClosure);
-  }
-
-  size_t size = totalSizeToAlloc(argLabels, argLabelLocs, hasTrailingClosure);
-
-  void *memory = ctx.Allocate(size, alignof(UnresolvedMemberExpr));
-  return new (memory) UnresolvedMemberExpr(dotLoc, nameLoc, name, arg,
-                                           argLabels, argLabelLocs,
-                                           hasTrailingClosure, implicit);
-}
-
 UnresolvedMemberExpr *UnresolvedMemberExpr::create(ASTContext &ctx,
                                                    SourceLoc dotLoc,
                                                    DeclNameLoc nameLoc,
@@ -1686,15 +1667,20 @@ CallExpr::CallExpr(Expr *fn, Expr *arg, bool Implicit,
 }
 
 CallExpr *CallExpr::create(ASTContext &ctx, Expr *fn, Expr *arg,
+                           ArrayRef<Identifier> argLabels,
+                           ArrayRef<SourceLoc> argLabelLocs,
+                           bool hasTrailingClosure,
                            bool implicit, Type type) {
-  // Inspect the argument to dig out the argument labels, their location, and
-  // whether there is a trailing closure.
   SmallVector<Identifier, 4> argLabelsScratch;
-  SmallVector<SourceLoc, 4> argLabelLocs;
-  bool hasTrailingClosure = false;
-  auto argLabels = getArgumentLabelsFromArgument(arg, argLabelsScratch,
-                                                 &argLabelLocs,
-                                                 &hasTrailingClosure);
+  SmallVector<SourceLoc, 4> argLabelLocsScratch;
+  if (argLabels.empty()) {
+    // Inspect the argument to dig out the argument labels, their location, and
+    // whether there is a trailing closure.
+    argLabels = getArgumentLabelsFromArgument(arg, argLabelsScratch,
+                                              &argLabelLocsScratch,
+                                              &hasTrailingClosure);
+    argLabelLocs = argLabelLocsScratch;
+  }
 
   size_t size = totalSizeToAlloc(argLabels, argLabelLocs, hasTrailingClosure);
 
diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
@@ -1523,7 +1523,7 @@ ParserResult<Expr> Parser::parseExprPostfix(Diag<> ID, bool isExprBasic) {
       Result = makeParserResult(
                  ParserStatus(closure),
                  CallExpr::create(Context, Result.get(), SourceLoc(),
-                                  { }, { Identifier() }, { }, SourceLoc(),
+                                  { }, { }, { }, SourceLoc(),
                                   closure.get(), /*implicit=*/false));
 
       if (Result.hasCodeCompletion())
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -2369,6 +2369,9 @@ namespace {
       // If there was an argument, apply it.
       if (auto arg = expr->getArgument()) {
         ApplyExpr *apply = CallExpr::create(tc.Context, result, arg,
+                                            expr->getArgumentLabels(),
+                                            expr->getArgumentLabelLocs(),
+                                            expr->hasTrailingClosure(),
                                             /*implicit=*/false);
         result = finishApply(apply, Type(), cs.getConstraintLocator(expr));
       }
@@ -6666,15 +6669,14 @@ Expr *TypeChecker::callWitness(Expr *base, DeclContext *dc,
   // FIXME: Standardize all callers to always provide all argument names,
   // rather than hack around this.
   CallExpr *call;
+  auto argLabels = witness->getFullName().getArgumentNames();
   if (arguments.size() == 1 &&
       (isVariadicWitness(witness) ||
-       argumentNamesMatch(arguments[0], 
-                          witness->getFullName().getArgumentNames()))) {
-    call = CallExpr::create(Context, unresolvedDot, arguments[0],
+       argumentNamesMatch(arguments[0], argLabels))) {
+    call = CallExpr::create(Context, unresolvedDot, arguments[0], { },
+                            { }, /*hasTrailingClosure=*/false,
                             /*implicit=*/true);
   } else {
-    auto names = witness->getFullName().getArgumentNames();
-
     // The tuple should have the source range enclosing its arguments unless
     // they are invalid or there are no arguments.
     SourceLoc TupleStartLoc = base->getStartLoc();
@@ -6690,7 +6692,7 @@ Expr *TypeChecker::callWitness(Expr *base, DeclContext *dc,
 
     call = CallExpr::create(Context, unresolvedDot,
                             TupleStartLoc,
-                            arguments, names, { },
+                            arguments, argLabels, { },
                             TupleEndLoc,
                             /*trailingClosure=*/nullptr,
                             /*implicit=*/true);
diff --git a/lib/Sema/CodeSynthesis.cpp b/lib/Sema/CodeSynthesis.cpp
@@ -2189,7 +2189,10 @@ swift::createDesignatedInitOverride(TypeChecker &tc,
     return ctor;
   }
 
-  Expr *superCall = CallExpr::create(ctx, ctorRef, ctorArgs, /*Implicit=*/true);
+  Expr *superCall =
+    CallExpr::create(ctx, ctorRef, ctorArgs,
+                     superclassCtor->getFullName().getArgumentNames(), { },
+                     /*hasTrailingClosure=*/false, /*implicit=*/true);
   if (superclassCtor->hasThrows()) {
     superCall = new (ctx) TryExpr(SourceLoc(), superCall, Type(),
                                   /*Implicit=*/true);
