Use token start locations

Author: David Ungar

include/swift/Parse/Parser.h

@@ -815,13 +815,14 @@ class Parser {
   /// Returns the proper location for a missing right brace, parenthesis, etc.
   SourceLoc getLocForMissingMatchingToken() const;
 
-  /// When encountering an error or a missing matching token (e.g. '}') return
-  /// its location. This value should be right at the end of the last token in
+  /// When encountering an error or a missing matching token (e.g. '}'), return
+  /// the location to use for it. This value should be at the last token in
   /// the ASTNode being parsed so that it nests within any enclosing nodes, and,
   /// for ASTScope lookups, it does not preceed any identifiers to be looked up.
-  /// The latter case obtaines when the parsing an interpolated string literal
-  /// because there may be identifiers to be looked up and they must precede the
-  /// location of a missing close brace.
+  /// However, the latter case does not hold when  parsing an interpolated
+  /// string literal because there may be identifiers to be looked up in the
+  /// literal and their locations will not precede the location of a missing
+  /// close brace.
   SourceLoc getErrorOrMissingLoc() const;
 
   /// Parse a comma separated list of some elements.

lib/AST/ASTVerifier.cpp

@@ -3655,7 +3655,7 @@ class Verifier : public ASTWalker {
           return;
         // FIXME: This is not working well for decl parents.
         // But it must work when using lazy ASTScopes for IterableDeclContexts
-        if (!Ctx.LangOpts.LazyASTScopes || !isa<IterableDeclContext>(D))
+        if (!isa<IterableDeclContext>(D))
           return;
       } else if (Stmt *S = Parent.getAsStmt()) {
         Enclosing = S->getSourceRange();

lib/AST/Expr.cpp

@@ -2228,13 +2228,7 @@ VarDecl * TapExpr::getVar() const {
 }
 
 SourceLoc TapExpr::getEndLoc() const {
-  // Before LazyASTScopes, was:
-  // return SubExpr ? SubExpr->getSourceRange() : SourceRange();
-
   // Include the body in the range, assuming the body follows the SubExpr.
-  // ASTScopes needs the body in the range in order to do lookups into the
-  // expressions in interpolated strings.
-
   // Also, be (perhaps overly) defensive about null pointers & invalid
   // locations.
   if (auto *const b = getBody()) {

lib/Parse/ParseExpr.cpp

@@ -1913,11 +1913,6 @@ ParserResult<Expr> Parser::parseExprStringLiteral() {
 
   // The start location of the entire string literal.
   SourceLoc Loc = Tok.getLoc();
-  // Put the close brace of the of the body of the AppendingExpr just inside
-  // of the literal so that it doesn't go past where a missing close brace
-  // for an enclosing IterableTypeDecl will be added.
-  // (See \c parseMatchingToken.)
-  SourceLoc EndLoc = Loc.getAdvancedLoc(Tok.getLength() - 1);
 
   StringRef OpenDelimiterStr, OpenQuoteStr, CloseQuoteStr, CloseDelimiterStr;
   unsigned DelimiterLength = Tok.getCustomDelimiterLen();
@@ -1996,7 +1991,8 @@ ParserResult<Expr> Parser::parseExprStringLiteral() {
   llvm::SaveAndRestore<Token> SavedTok(Tok);
   llvm::SaveAndRestore<ParsedTrivia> SavedLeadingTrivia(LeadingTrivia);
   llvm::SaveAndRestore<ParsedTrivia> SavedTrailingTrivia(TrailingTrivia);
-  // For errors, we need the real PreviousLoc
+  // For errors, we need the real PreviousLoc, i.e. the start of the
+  // whole InterpolatedStringLiteral.
   llvm::SaveAndRestore<SourceLoc> SavedPreviousLoc(PreviousLoc);
 
   // We're not in a place where an interpolation would be valid.
@@ -2036,8 +2032,9 @@ ParserResult<Expr> Parser::parseExprStringLiteral() {
     Status = parseStringSegments(Segments, EntireTok, InterpolationVar, 
                                  Stmts, LiteralCapacity, InterpolationCount);
 
-    // See the definition of \c EndLoc above.
-    auto Body = BraceStmt::create(Context, Loc, Stmts, EndLoc,
+    // At this point, PreviousLoc points to the last token parsed within
+    // the body, so use that for the brace statement location.
+    auto Body = BraceStmt::create(Context, Loc, Stmts, PreviousLoc,
                                   /*implicit=*/false);
     AppendingExpr = new (Context) TapExpr(nullptr, Body);
   }

lib/Parse/Parser.cpp

@@ -988,30 +988,24 @@ bool Parser::parseMatchingToken(tok K, SourceLoc &TokLoc, Diag<> ErrorDiag,
 }
 
 SourceLoc Parser::getLocForMissingMatchingToken() const {
-  // The right brace, parenthesis, etc. must include the whole of the previous
-  // token in order so that an unexpanded lazy \c IterableTypeScope includes its
-  // contents.
+  // At present, use the same location whether it's an error or whether
+  // the matching token is missing.
+  // Both cases supply a location for something the user didn't type.
   return getErrorOrMissingLoc();
 }
 
 SourceLoc Parser::getErrorOrMissingLoc() const {
-  // LazyASTScopes require that the ends of types, etc. which are at the end of
-  // \c IterableTypeContext \c Decls, such as \c StructDecl not be beyond the
-  // end of the enclosing \c Decl.
-
-  // The missing right brace, parenthesis, etc. must include the whole of the
-  // previous token in order so that an unexpanded lazy \c IterableTypeScope
-  // includes its contents.
-
-  auto const PreviousTok = Lexer::getTokenAtLocation(Context.SourceMgr,
-                                                     PreviousLoc);
-  // If it's a string literal, it might be an InterpolatedStringLiteral.
-  // In that case the missing close paren, etc. needs to go at the end
-  // because there might be things to be looked up for ASTScope in the
-  // middle.
-  return PreviousTok.getKind() != tok::string_literal
-    ? PreviousLoc
-    : PreviousLoc.getAdvancedLoc(PreviousTok.getLength() - 1);
+  // The next token might start a new enclosing construct,
+  // and SourceLoc's are always at the start of a token (for example, for
+  // fixits, so use the previous token's SourceLoc and allow a subnode to end
+  // right at the same place as its supernode.
+
+  // The tricky case is when the previous token is an InterpolatedStringLiteral.
+  // Then, there will be names in scope whose SourceLoc is *after* the
+  // the location of a missing close brace.
+  // ASTScope tree creation will have to cope.
+
+  return PreviousLoc;
 }
 
 static SyntaxKind getListElementKind(SyntaxKind ListKind) {