---

yaml
---
r: 348695
b: refs/heads/master
c: ffa8fbd
h: refs/heads/master
i:
  348693: 1212050
  348691: 7393c9f
  348687: efe2638

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 9a4bc66998a97c3908a16e2265940bdef2e97637
+refs/heads/master: ffa8fbda355555ea85a24cc5c59279552413c37e
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/Parse/ParsedRawSyntaxNode.h

@@ -109,10 +109,12 @@ class ParsedRawSyntaxNode {
   }
 
   ParsedRawSyntaxNode(syntax::SyntaxKind k, tok tokKind,
-                      CharSourceRange r, OpaqueSyntaxNode n)
+                      CharSourceRange r, OpaqueSyntaxNode n,
+                      bool IsMissing = false)
     : RecordedData{n, r},
       SynKind(uint16_t(k)), TokKind(uint16_t(tokKind)),
-      DK(DataKind::Recorded) {
+      DK(DataKind::Recorded),
+      IsMissing(IsMissing) {
     assert(getKind() == k && "Syntax kind with too large value!");
     assert(getTokenKind() == tokKind && "Token kind with too large value!");
   }
@@ -197,12 +199,14 @@ class ParsedRawSyntaxNode {
     return copy;
   }
 
-  CharSourceRange getDeferredRange() const {
+  CharSourceRange getDeferredRange(bool includeTrivia) const {
     switch (DK) { 
     case DataKind::DeferredLayout:
-      return getDeferredLayoutRange();
+      return getDeferredLayoutRange(includeTrivia);
     case DataKind::DeferredToken:
-      return getDeferredTokenRange();
+      return includeTrivia
+        ? getDeferredTokenRangeWithTrivia()
+        : getDeferredTokenRange();
     default:
       llvm_unreachable("node not deferred");
     }
@@ -227,18 +231,19 @@ class ParsedRawSyntaxNode {
 
   // Deferred Layout Data ====================================================//
 
-  CharSourceRange getDeferredLayoutRange() const {
+  CharSourceRange getDeferredLayoutRange(bool includeTrivia) const {
     assert(DK == DataKind::DeferredLayout);
-    assert(!DeferredLayout.Children.empty());
-    auto getLastNonNullChild = [this]() -> const ParsedRawSyntaxNode & {
-      for (auto &Child : llvm::reverse(getDeferredChildren()))
-        if (!Child.isNull())
-          return Child;
-      llvm_unreachable("layout node without non-null children");
+    auto HasValidRange = [includeTrivia](const ParsedRawSyntaxNode &Child) {
+      return !Child.isNull() && !Child.isMissing() &&
+        Child.getDeferredRange(includeTrivia).isValid();
     };
-    auto firstRange = DeferredLayout.Children.front().getDeferredRange();
-    auto lastRange = getLastNonNullChild().getDeferredRange();
-    firstRange.widen(lastRange);
+    auto first = llvm::find_if(getDeferredChildren(), HasValidRange);
+    if (first == getDeferredChildren().end())
+      return CharSourceRange();
+    auto last = llvm::find_if(llvm::reverse(getDeferredChildren()),
+                              HasValidRange);
+    auto firstRange = first->getDeferredRange(includeTrivia);
+    firstRange.widen(last->getDeferredRange(includeTrivia));
     return firstRange;
   }
   ArrayRef<ParsedRawSyntaxNode> getDeferredChildren() const {

trunk/include/swift/Parse/ParsedRawSyntaxRecorder.h

@@ -73,6 +73,10 @@ class ParsedRawSyntaxRecorder {
   /// Used for incremental re-parsing.
   ParsedRawSyntaxNode lookupNode(size_t lexerOffset, SourceLoc loc,
                                  syntax::SyntaxKind kind);
+
+  #ifndef NDEBUG
+  static void verifyElementRanges(ArrayRef<ParsedRawSyntaxNode> elements);
+  #endif
 };
 
 } // end namespace swift

trunk/include/swift/Parse/ParsedSyntaxBuilders.h.gyb

@@ -62,9 +62,9 @@ public:
 %     end
 
   Parsed${node.name} build();
-  Parsed${node.name} makeDeferred();
 
 private:
+  Parsed${node.name} makeDeferred();
   Parsed${node.name} record();
   void finishLayout(bool deferred);
 };

trunk/include/swift/Parse/ParsedSyntaxRecorder.h.gyb

@@ -43,23 +43,22 @@ struct ParsedSyntaxRecorder {
 %     end
 %     child_params = ', '.join(child_params)
 private:
-  static Parsed${node.name} record${node.syntax_kind}(${child_params},
+  static Parsed${node.name} record${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout,
                                               ParsedRawSyntaxRecorder &rec);
-public:
-  static Parsed${node.name} defer${node.syntax_kind}(${child_params},
+  static Parsed${node.name} defer${node.syntax_kind}(MutableArrayRef<ParsedRawSyntaxNode> layout,
                                               SyntaxParsingContext &SPCtx);
+public:
   static Parsed${node.name} make${node.syntax_kind}(${child_params},
                                               SyntaxParsingContext &SPCtx);
 %   elif node.is_syntax_collection():
 private:
   static Parsed${node.name} record${node.syntax_kind}(
-      MutableArrayRef<Parsed${node.collection_element_type}> elts,
+      MutableArrayRef<ParsedRawSyntaxNode> layout,
       ParsedRawSyntaxRecorder &rec);
-
-public:
   static Parsed${node.name} defer${node.syntax_kind}(
-      MutableArrayRef<Parsed${node.collection_element_type}> elts,
+      MutableArrayRef<ParsedRawSyntaxNode> layout,
       SyntaxParsingContext &SPCtx);
+public:
   static Parsed${node.name} make${node.syntax_kind}(
       MutableArrayRef<Parsed${node.collection_element_type}> elts,
       SyntaxParsingContext &SPCtx);
@@ -69,14 +68,12 @@ public:
 %   elif node.is_unknown():
 private:
   static Parsed${node.name} record${node.syntax_kind}(
-      MutableArrayRef<ParsedSyntax> elts,
+      MutableArrayRef<ParsedRawSyntaxNode> layout,
       ParsedRawSyntaxRecorder &rec);
-
-public:
   static Parsed${node.name} defer${node.syntax_kind}(
-      MutableArrayRef<ParsedSyntax> elts,
+      MutableArrayRef<ParsedRawSyntaxNode> layout,
       SyntaxParsingContext &SPCtx);
-
+public:
   static Parsed${node.name} make${node.syntax_kind}(
       MutableArrayRef<ParsedSyntax> elts,
       SyntaxParsingContext &SPCtx);

trunk/lib/Parse/ParseExpr.cpp

@@ -1498,8 +1498,8 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
           ParsedSyntaxRecorder::makeIdentifierPattern(
                                   SyntaxContext->popToken(), *SyntaxContext);
       ParsedExprSyntax ExprNode =
-          ParsedSyntaxRecorder::deferUnresolvedPatternExpr(std::move(PatternNode),
-                                                           *SyntaxContext);
+          ParsedSyntaxRecorder::makeUnresolvedPatternExpr(std::move(PatternNode),
+                                                          *SyntaxContext);
       SyntaxContext->addSyntax(std::move(ExprNode));
       return makeParserResult(new (Context) UnresolvedPatternExpr(pattern));
     }

trunk/lib/Parse/ParseType.cpp

@@ -399,7 +399,7 @@ Parser::TypeASTResult Parser::parseType(Diag<> MessageID,
       diagnose(Tok.getLoc(), DiagID)
           .fixItInsert(ArrowLoc, "throws ")
           .fixItRemove(Tok.getLoc());
-      Throws = consumeTokenSyntax();
+      ignoreToken();
     }
     ParserResult<TypeRepr> SecondHalf =
         parseType(diag::expected_type_function_result);
@@ -944,7 +944,8 @@ Parser::TypeResult Parser::parseOldStyleProtocolComposition() {
       replacement = "Any";
     } else {
       auto extractText = [&](ParsedTypeSyntax &Type) -> StringRef {
-        auto SourceRange = Type.getRaw().getDeferredRange();
+        auto SourceRange = Type.getRaw()
+          .getDeferredRange(/*includeTrivia=*/false);
         return SourceMgr.extractText(SourceRange);
       };
       auto Begin = Protocols.begin();
@@ -1061,18 +1062,15 @@ Parser::TypeResult Parser::parseTypeTupleBody() {
       // Consume a name.
       NameLoc = Tok.getLoc();
       Name = consumeArgumentLabelSyntax();
-      LocalJunk.push_back(Name->copyDeferred());
 
       // If there is a second name, consume it as well.
       if (Tok.canBeArgumentLabel()) {
         SecondNameLoc = Tok.getLoc();
         SecondName = consumeArgumentLabelSyntax();
-        LocalJunk.push_back(SecondName->copyDeferred());
       }
 
       // Consume the ':'.
       if ((Colon = consumeTokenSyntaxIf(tok::colon))) {
-        LocalJunk.push_back(Colon->copyDeferred());
         // If we succeed, then we successfully parsed a label.
         if (Backtracking)
           Backtracking->cancelBacktrack();
@@ -1089,6 +1087,18 @@ Parser::TypeResult Parser::parseTypeTupleBody() {
       IsInOutObsoleted = false;
     }
 
+    if (!Backtracking || !Backtracking->willBacktrack()) {
+      if (Name)
+        LocalJunk.push_back(Name->copyDeferred());
+      if (SecondName)
+        LocalJunk.push_back(SecondName->copyDeferred());
+      if (Colon)
+        LocalJunk.push_back(Colon->copyDeferred());
+    } else if (Backtracking && Backtracking->willBacktrack()) {
+      Name.reset();
+      SecondName.reset();
+      assert(!Colon.hasValue());
+    }
     Backtracking.reset();
 
     // Parse the type annotation.

trunk/lib/Parse/ParsedRawSyntaxRecorder.cpp

@@ -53,7 +53,8 @@ ParsedRawSyntaxNode
 ParsedRawSyntaxRecorder::recordMissingToken(tok tokenKind, SourceLoc loc) {
   CharSourceRange range{loc, 0};
   OpaqueSyntaxNode n = SPActions->recordMissingToken(tokenKind, loc);
-  return ParsedRawSyntaxNode{SyntaxKind::Token, tokenKind, range, n};
+  return ParsedRawSyntaxNode{SyntaxKind::Token, tokenKind, range, n,
+                             /*isMissing=*/true};
 }
 
 static ParsedRawSyntaxNode
@@ -128,3 +129,21 @@ ParsedRawSyntaxRecorder::lookupNode(size_t lexerOffset, SourceLoc loc,
   CharSourceRange range{loc, unsigned(length)};
   return ParsedRawSyntaxNode{kind, tok::unknown, range, n};
 }
+
+#ifndef NDEBUG
+void ParsedRawSyntaxRecorder::verifyElementRanges(ArrayRef<ParsedRawSyntaxNode> elements) {
+  SourceLoc prevEndLoc;
+  for (const auto &elem: elements) {
+    if (elem.isMissing() || elem.isNull())
+      continue;
+    CharSourceRange range = elem.isRecorded()
+      ? elem.getRecordedRange()
+      : elem.getDeferredRange(/*includeTrivia=*/true);
+    if (range.isValid()) {
+      assert((prevEndLoc.isInvalid() || range.getStart() == prevEndLoc)
+             && "Non-contiguous child ranges?");
+      prevEndLoc = range.getEnd();
+    }
+  }
+}
+#endif

trunk/lib/Parse/ParsedSyntaxBuilders.cpp.gyb

@@ -120,6 +120,10 @@ void Parsed${node.name}Builder::finishLayout(bool deferred) {
   }
 %     end
 %   end
+
+#ifndef NDEBUG
+  ParsedRawSyntaxRecorder::verifyElementRanges(Layout);
+#endif
 % end
 }