---

yaml
---
r: 348783
b: refs/heads/master
c: 9b7ab6b
h: refs/heads/master
i:
  348781: 67b37df
  348779: 12d6a7e
  348775: b4a8335
  348767: c10adcc

Author: CodaFi

[refs]

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

trunk/include/swift/AST/DiagnosticConsumer.h

@@ -38,10 +38,17 @@ enum class DiagnosticKind : uint8_t {
   Note
 };
 
-/// Extra information carried along with a diagnostic, which may or
-/// may not be of interest to a given diagnostic consumer.
+/// Information about a diagnostic passed to DiagnosticConsumers.
 struct DiagnosticInfo {
   DiagID ID = DiagID(0);
+  SourceLoc Loc;
+  DiagnosticKind Kind;
+  StringRef FormatString;
+  ArrayRef<DiagnosticArgument> FormatArgs;
+  SourceLoc BufferIndirectlyCausingDiagnostic;
+
+  /// DiagnosticInfo of notes which are children of this diagnostic, if any
+  ArrayRef<DiagnosticInfo *> ChildDiagnosticInfo;
 
   /// Represents a fix-it, a replacement of one range of text with another.
   class FixIt {
@@ -60,6 +67,24 @@ struct DiagnosticInfo {
 
   /// Extra source ranges that are attached to the diagnostic.
   ArrayRef<FixIt> FixIts;
+
+  /// This is a note which has a parent error or warning
+  bool IsChildNote = false;
+
+  DiagnosticInfo() {}
+
+  DiagnosticInfo(DiagID ID, SourceLoc Loc, DiagnosticKind Kind,
+                 StringRef FormatString,
+                 ArrayRef<DiagnosticArgument> FormatArgs,
+                 SourceLoc BufferIndirectlyCausingDiagnostic,
+                 ArrayRef<DiagnosticInfo *> ChildDiagnosticInfo,
+                 ArrayRef<CharSourceRange> Ranges, ArrayRef<FixIt> FixIts,
+                 bool IsChildNote)
+      : ID(ID), Loc(Loc), Kind(Kind), FormatString(FormatString),
+        FormatArgs(FormatArgs),
+        BufferIndirectlyCausingDiagnostic(BufferIndirectlyCausingDiagnostic),
+        ChildDiagnosticInfo(ChildDiagnosticInfo), Ranges(Ranges),
+        FixIts(FixIts), IsChildNote(IsChildNote) {}
 };
 
 /// Abstract interface for classes that present diagnostics to the user.

trunk/include/swift/AST/DiagnosticEngine.h

@@ -337,7 +337,9 @@ namespace swift {
     SmallVector<DiagnosticArgument, 3> Args;
     SmallVector<CharSourceRange, 2> Ranges;
     SmallVector<FixIt, 2> FixIts;
+    std::vector<Diagnostic> ChildNotes;
     SourceLoc Loc;
+    bool IsChildNote = false;
     const Decl *Decl = nullptr;
 
     friend DiagnosticEngine;
@@ -362,10 +364,13 @@ namespace swift {
     ArrayRef<DiagnosticArgument> getArgs() const { return Args; }
     ArrayRef<CharSourceRange> getRanges() const { return Ranges; }
     ArrayRef<FixIt> getFixIts() const { return FixIts; }
+    ArrayRef<Diagnostic> getChildNotes() const { return ChildNotes; }
+    bool isChildNote() const { return IsChildNote; }
     SourceLoc getLoc() const { return Loc; }
     const class Decl *getDecl() const { return Decl; }
 
     void setLoc(SourceLoc loc) { Loc = loc; }
+    void setIsChildNote(bool isChildNote) { IsChildNote = isChildNote; }
     void setDecl(const class Decl *decl) { Decl = decl; }
 
     /// Returns true if this object represents a particular diagnostic.
@@ -386,6 +391,8 @@ namespace swift {
     void addFixIt(FixIt &&F) {
       FixIts.push_back(std::move(F));
     }
+
+    void addChildNote(Diagnostic &&D);
   };
 
   /// Describes an in-flight diagnostic, which is currently active
@@ -665,7 +672,8 @@ namespace swift {
 
     friend class InFlightDiagnostic;
     friend class DiagnosticTransaction;
-    
+    friend class CompoundDiagnosticTransaction;
+
   public:
     explicit DiagnosticEngine(SourceManager &SourceMgr)
         : SourceMgr(SourceMgr), ActiveDiagnostic(),
@@ -878,6 +886,15 @@ namespace swift {
       return diagnose(decl, Diagnostic(id, std::move(args)...));
     }
 
+    /// Emit a parent diagnostic and attached notes.
+    ///
+    /// \param parentDiag An InFlightDiagnostic representing the parent diag.
+    ///
+    /// \param builder A closure which builds and emits notes to be attached to
+    /// the parent diag.
+    void diagnoseWithNotes(InFlightDiagnostic parentDiag,
+                           llvm::function_ref<void(void)> builder);
+
     /// \returns true if diagnostic is marked with PointsToFirstBadToken
     /// option.
     bool isDiagnosticPointsToFirstBadToken(DiagID id) const;
@@ -905,6 +922,10 @@ namespace swift {
     /// Retrieve the active diagnostic.
     Diagnostic &getActiveDiagnostic() { return *ActiveDiagnostic; }
 
+    /// Generate DiagnosticInfo for a Diagnostic to be passed to consumers.
+    Optional<DiagnosticInfo>
+    diagnosticInfoForDiagnostic(const Diagnostic &diagnostic);
+
     /// Send \c diag to all diagnostic consumers.
     void emitDiagnostic(const Diagnostic &diag);
 
@@ -945,6 +966,7 @@ namespace swift {
   /// in LIFO order. An open transaction is implicitly committed upon
   /// destruction.
   class DiagnosticTransaction {
+  protected:
     DiagnosticEngine &Engine;
 
     /// How many tentative diagnostics there were when the transaction
@@ -968,7 +990,6 @@ namespace swift {
         Depth(Engine.TransactionCount),
         IsOpen(true)
     {
-      assert(!Engine.ActiveDiagnostic);
       Engine.TransactionCount++;
     }
 
@@ -1011,6 +1032,61 @@ namespace swift {
              "transactions must be closed LIFO");
     }
   };
+
+  /// Represents a diagnostic transaction which constructs a compound diagnostic
+  /// from any diagnostics emitted inside. A compound diagnostic consists of a
+  /// parent error, warning, or remark followed by a variable number of child
+  /// notes. The semantics are otherwise the same as a regular
+  /// DiagnosticTransaction.
+  class CompoundDiagnosticTransaction : public DiagnosticTransaction {
+  public:
+    explicit CompoundDiagnosticTransaction(DiagnosticEngine &engine)
+        : DiagnosticTransaction(engine) {}
+
+    ~CompoundDiagnosticTransaction() {
+      if (IsOpen) {
+        commit();
+      }
+
+      if (Depth == 0) {
+        Engine.TransactionStrings.clear();
+        Engine.TransactionAllocator.Reset();
+      }
+    }
+
+    void commit() {
+      assert(PrevDiagnostics < Engine.TentativeDiagnostics.size() &&
+             "CompoundDiagnosticTransaction must contain at least one diag");
+
+      // The first diagnostic is assumed to be the parent. If this is not an
+      // error or warning, we'll assert later when trying to add children.
+      Diagnostic &parent = Engine.TentativeDiagnostics[PrevDiagnostics];
+
+      // Associate the children with the parent.
+      for (auto diag =
+               Engine.TentativeDiagnostics.begin() + PrevDiagnostics + 1;
+           diag != Engine.TentativeDiagnostics.end(); ++diag) {
+        diag->setIsChildNote(true);
+        parent.addChildNote(std::move(*diag));
+      }
+
+      // Erase the children, they'll be emitted alongside their parent.
+      Engine.TentativeDiagnostics.erase(Engine.TentativeDiagnostics.begin() +
+                                            PrevDiagnostics + 1,
+                                        Engine.TentativeDiagnostics.end());
+
+      DiagnosticTransaction::commit();
+    }
+  };
+
+  inline void
+  DiagnosticEngine::diagnoseWithNotes(InFlightDiagnostic parentDiag,
+                                      llvm::function_ref<void(void)> builder) {
+    CompoundDiagnosticTransaction transaction(*this);
+    parentDiag.flush();
+    builder();
+  }
+
 } // end namespace swift
 
 #endif

trunk/include/swift/Basic/STLExtras.h

@@ -253,7 +253,7 @@ inline Iterator prev_or_begin(Iterator it, Iterator begin) {
 
 /// A range of iterators.
 /// TODO: Add `llvm::iterator_range::empty()`, then remove this helper, along
-/// with the superfluous FilterIterator and TransformIterator.
+/// with the superfluous TransformIterator.
 template<typename Iterator>
 class IteratorRange {
   Iterator First, Last;
@@ -279,136 +279,6 @@ makeIteratorRange(Iterator first, Iterator last) {
   return IteratorRange<Iterator>(first, last);
 }
 
-/// An iterator that filters the results of an underlying forward
-/// iterator, only passing through those values that satisfy a predicate.
-///
-/// \tparam Iterator the underlying iterator.
-///
-/// \tparam Predicate A predicate that determines whether a value of the
-/// underlying iterator is available in the resulting sequence.
-template<typename Iterator, typename Predicate>
-class FilterIterator {
-  Iterator Current, End;
-
-  /// FIXME: Could optimize away this storage with EBCO tricks.
-  Predicate Pred;
-
-  /// Skip any non-matching elements.
-  void skipNonMatching() {
-    while (Current != End && !Pred(*Current))
-      ++Current;
-  }
-
-public:
-  /// Used to indicate when the current iterator has already been
-  /// "primed", meaning that it's at the end or points to a value that
-  /// satisfies the predicate.
-  enum PrimedT { Primed };
-
-  using iterator_category = std::forward_iterator_tag;
-  using value_type = typename std::iterator_traits<Iterator>::value_type;
-  using reference = typename std::iterator_traits<Iterator>::reference;
-  using pointer = typename std::iterator_traits<Iterator>::pointer;
-  using difference_type =
-      typename std::iterator_traits<Iterator>::difference_type;
-
-  /// Construct a new filtering iterator for the given iterator range
-  /// and predicate.
-  FilterIterator(Iterator current, Iterator end, Predicate pred)
-    : Current(current), End(end), Pred(pred) 
-  {
-    // Prime the iterator.
-    skipNonMatching();
-  }
-
-  /// Construct a new filtering iterator for the given iterator range
-  /// and predicate, where the iterator range has already been
-  /// "primed" by ensuring that it is empty or the current iterator
-  /// points to something that matches the predicate.
-  FilterIterator(Iterator current, Iterator end, Predicate pred, PrimedT)
-    : Current(current), End(end), Pred(pred) 
-  { 
-    // Assert that the iterators have already been primed.
-    assert(Current == End || Pred(*Current) && "Not primed!");
-  }
-
-  reference operator*() const {
-    return *Current;
-  }
-
-  pointer operator->() const {
-    return Current.operator->();
-  }
-
-  FilterIterator &operator++() {
-    ++Current;
-    skipNonMatching();
-    return *this;
-  }
-
-  FilterIterator operator++(int) {
-    FilterIterator old = *this;
-    ++*this;
-    return old;
-  }
-
-  friend bool operator==(FilterIterator lhs, FilterIterator rhs) {
-    return lhs.Current == rhs.Current;
-  }
-  friend bool operator!=(FilterIterator lhs, FilterIterator rhs) {
-    return !(lhs == rhs);
-  }
-};
-
-/// Create a new filter iterator.
-template<typename Iterator, typename Predicate>
-inline FilterIterator<Iterator, Predicate> 
-makeFilterIterator(Iterator current, Iterator end, Predicate pred) {
-  return FilterIterator<Iterator, Predicate>(current, end, pred);
-}
-
-/// A range filtered by a specific predicate.
-template<typename Range, typename Predicate>
-class FilterRange {
-  using Iterator = typename Range::iterator;
-
-  Iterator First, Last;
-  Predicate Pred;
-
-public:
-  using iterator = FilterIterator<Iterator, Predicate>;
-
-  FilterRange(Range range, Predicate pred)
-    : First(range.begin()), Last(range.end()), Pred(pred) 
-  { 
-    // Prime the sequence.
-    while (First != Last && !Pred(*First))
-      ++First;
-  }
-
-  iterator begin() const { 
-    return iterator(First, Last, Pred, iterator::Primed); 
-  }
-
-  iterator end() const { 
-    return iterator(Last, Last, Pred, iterator::Primed); 
-  }
-
-  bool empty() const { return First == Last; }
-
-  typename std::iterator_traits<iterator>::value_type front() const { 
-    assert(!empty() && "Front of empty range");
-    return *begin(); 
-  }
-};
-
-/// Create a new filter range.
-template<typename Range, typename Predicate>
-inline FilterRange<Range, Predicate> 
-makeFilterRange(Range range, Predicate pred) {
-  return FilterRange<Range, Predicate>(range, pred);
-}
-
 /// An iterator that transforms the result of an underlying bidirectional
 /// iterator with a given operation.
 ///
@@ -488,7 +358,7 @@ class TransformRange {
   Operation Op;
 
 public:
-  using iterator = TransformIterator<typename Range::iterator, Operation>;
+  using iterator = TransformIterator<decltype(Rng.begin()), Operation>;
 
   TransformRange(Range range, Operation op)
     : Rng(range), Op(op) { }
@@ -497,6 +367,20 @@ class TransformRange {
   iterator end() const { return iterator(Rng.end(), Op); }
   bool empty() const { return begin() == end(); }
 
+  // The dummy template parameter keeps 'size()' from being eagerly
+  // instantiated.
+  template <typename Dummy = Range>
+  typename function_traits<decltype(&Dummy::size)>::result_type
+  size() const {
+    return Rng.size();
+  }
+
+  template <typename Index>
+  typename function_traits<Operation>::result_type
+  operator[](Index index) const {
+    return Op(Rng[index]);
+  }
+
   typename std::iterator_traits<iterator>::value_type front() const { 
     assert(!empty() && "Front of empty range");
     return *begin();