[ConstExpr] Emit traceback when failing during nested call evaluation (#18123)

When emitting a constexpr-evaluation failure message, this change emits
a trace of the calls the evaluator followed to generate the failure.

To make the output easier to read, calls on the same source line as the
failing location are elided from the output. So for example:

func foo() -> Bool {
  print("Un-constant")
  return true
}

test.swift:6:1: error: #assert condition not constant
^
test.swift:2:9: note: expression not evaluable as constant here
  print("Un-constant")

Notice there is no stack trace for the evaluation of the lambda.

Author: jmolloy

include/swift/AST/DiagnosticsSIL.def

@@ -221,6 +221,9 @@ WARNING(designated_init_in_cross_module_extension,none,
 NOTE(designated_init_c_struct_fix,none,
      "use \"self.init()\" to initialize the struct with zero values", ())
 
+NOTE(constexpr_called_from, none, "when called from here", ())
+NOTE(constexpr_not_evaluable, none,
+     "expression not evaluable as constant here", ())
 
 // SWIFT_ENABLE_TENSORFLOW
 // TensorFlow Support Diagnostics.
@@ -263,7 +266,6 @@ ERROR(tf_op_misuse, none,
 NOTE(tf_op_misuse_note, none,
      "%0", (StringRef))
 
-
 // Control flow diagnostics.
 ERROR(missing_return,none,
       "missing return in a %select{function|closure}1 expected to return %0",

include/swift/SIL/SILConstants.h

@@ -26,12 +26,13 @@ class SILValue;
 class SILBuilder;
 class SerializedSILLoader;
 
-struct APIntSymbolicValue;
 struct APFloatSymbolicValue;
-struct EnumWithPayloadSymbolicValue;
+struct APIntSymbolicValue;
 struct ArraySymbolicValue;
 struct DerivedAddressValue;
+struct EnumWithPayloadSymbolicValue;
 struct SymbolicValueMemoryObject;
+struct UnknownSymbolicValue;
 
 /// When we fail to constant fold a value, this captures a reason why,
 /// allowing the caller to produce a specific diagnostic.  The "Unknown"
@@ -65,6 +66,7 @@ enum class UnknownReason {
 /// symbolic values (e.g. to save memory).  It provides a simpler public
 /// interface though.
 class SymbolicValue {
+private:
   enum RepresentationKind {
     /// This value is an alloc stack that is has not (yet) been initialized
     /// by flow-sensitive analysis.
@@ -132,11 +134,9 @@ class SymbolicValue {
   };
 
   union {
-    /// When the value is Unknown, this contains the value that was the
+    /// When the value is Unknown, this contains information about the
     /// unfoldable part of the computation.
-    ///
-    /// TODO: make this a more rich representation.
-    SILNode *unknown;
+    UnknownSymbolicValue *unknown;
 
     /// This is always a SILType with an object category.  This is the value
     /// of the underlying instance type, not the MetatypeType.
@@ -268,23 +268,21 @@ class SymbolicValue {
     return kind != Unknown && kind != UninitMemory;
   }
 
-  static SymbolicValue getUnknown(SILNode *node, UnknownReason reason) {
-    assert(node && "node must be present");
-    SymbolicValue result;
-    result.representationKind = RK_Unknown;
-    result.value.unknown = node;
-    result.aux.unknown_reason = reason;
-    return result;
-  }
+  static SymbolicValue getUnknown(SILNode *node, UnknownReason reason,
+                                  llvm::ArrayRef<SourceLoc> callStack,
+                                  llvm::BumpPtrAllocator &allocator);
 
+  /// Return true if this represents an unknown result.
   bool isUnknown() const { return getKind() == Unknown; }
 
-  /// Return information about an unknown result, including the SIL node that
-  /// is a problem, and the reason it is an issue.
-  std::pair<SILNode *, UnknownReason> getUnknownValue() const {
-    assert(representationKind == RK_Unknown);
-    return {value.unknown, aux.unknown_reason};
-  }
+  /// Return the call stack for an unknown result.
+  ArrayRef<SourceLoc> getUnknownCallStack() const;
+
+  /// Return the node that triggered an unknown result.
+  SILNode *getUnknownNode() const;
+
+  /// Return the reason an unknown result was generated.
+  UnknownReason getUnknownReason() const;
 
   static SymbolicValue getUninitMemory() {
     SymbolicValue result;

lib/SIL/SILConstants.cpp

@@ -36,9 +36,8 @@ void SymbolicValue::print(llvm::raw_ostream &os, unsigned indent) const {
     os << "uninit\n";
     return;
   case RK_Unknown: {
-    std::pair<SILNode *, UnknownReason> unknown = getUnknownValue();
-    os << "unknown(" << (int)unknown.second << "): ";
-    unknown.first->dump();
+    os << "unknown(" << (int)getUnknownReason() << "): ";
+    getUnknownNode()->dump();
     return;
   }
   case RK_Metatype:
@@ -485,6 +484,88 @@ ArrayRef<SymbolicValue> SymbolicValue::getAggregateValue() const {
   return ArrayRef<SymbolicValue>(value.aggregate, aux.aggregate_numElements);
 }
 
+//===----------------------------------------------------------------------===//
+// Unknown
+//===----------------------------------------------------------------------===//
+
+namespace swift {
+/// When the value is Unknown, this contains information about the unfoldable
+/// part of the computation.
+struct alignas(SourceLoc) UnknownSymbolicValue final
+    : private llvm::TrailingObjects<UnknownSymbolicValue, SourceLoc> {
+  friend class llvm::TrailingObjects<UnknownSymbolicValue, SourceLoc>;
+
+  /// The value that was unfoldable.
+  SILNode *node;
+
+  /// A more explanatory reason for the value being unknown.
+  UnknownReason reason;
+
+  /// The number of elements in the call stack.
+  unsigned call_stack_size;
+
+  static UnknownSymbolicValue *create(SILNode *node, UnknownReason reason,
+                                      ArrayRef<SourceLoc> elements,
+                                      llvm::BumpPtrAllocator &allocator) {
+    auto byteSize =
+        UnknownSymbolicValue::totalSizeToAlloc<SourceLoc>(elements.size());
+    auto rawMem = allocator.Allocate(byteSize, alignof(UnknownSymbolicValue));
+
+    // Placement-new the value inside the memory we just allocated.
+    auto value = ::new (rawMem) UnknownSymbolicValue(
+        node, reason, static_cast<unsigned>(elements.size()));
+    std::uninitialized_copy(elements.begin(), elements.end(),
+                            value->getTrailingObjects<SourceLoc>());
+    return value;
+  }
+
+  ArrayRef<SourceLoc> getCallStack() const {
+    return {getTrailingObjects<SourceLoc>(), call_stack_size};
+  }
+
+  // This is used by the llvm::TrailingObjects base class.
+  size_t numTrailingObjects(OverloadToken<SourceLoc>) const {
+    return call_stack_size;
+  }
+
+private:
+  UnknownSymbolicValue() = delete;
+  UnknownSymbolicValue(const UnknownSymbolicValue &) = delete;
+  UnknownSymbolicValue(SILNode *node, UnknownReason reason,
+                       unsigned call_stack_size)
+      : node(node), reason(reason), call_stack_size(call_stack_size) {}
+};
+} // namespace swift
+
+SymbolicValue SymbolicValue::getUnknown(SILNode *node, UnknownReason reason,
+                                        llvm::ArrayRef<SourceLoc> callStack,
+                                        llvm::BumpPtrAllocator &allocator) {
+  auto *rawCallStack = allocator.Allocate<SourceLoc>(callStack.size());
+  std::uninitialized_copy(callStack.begin(), callStack.end(), rawCallStack);
+
+  assert(node && "node must be present");
+  SymbolicValue result;
+  result.representationKind = RK_Unknown;
+  result.value.unknown =
+      UnknownSymbolicValue::create(node, reason, callStack, allocator);
+  return result;
+}
+
+ArrayRef<SourceLoc> SymbolicValue::getUnknownCallStack() const {
+  assert(getKind() == Unknown);
+  return value.unknown->getCallStack();
+}
+
+SILNode *SymbolicValue::getUnknownNode() const {
+  assert(getKind() == Unknown);
+  return value.unknown->node;
+}
+
+UnknownReason SymbolicValue::getUnknownReason() const {
+  assert(getKind() == Unknown);
+  return value.unknown->reason;
+}
+
 //===----------------------------------------------------------------------===//
 // Enums
 //===----------------------------------------------------------------------===//
@@ -751,16 +832,35 @@ SymbolicValue SymbolicValue::lookThroughSingleElementAggregates() const {
   }
 }
 
+/// Emits an explanatory note if there is useful information to note or if there
+/// is an interesting SourceLoc to point at.
+/// Returns true if a diagnostic was emitted.
+static bool emitNoteDiagnostic(SILInstruction *badInst, UnknownReason reason,
+                               SILLocation fallbackLoc, std::string error) {
+  auto loc = skipInternalLocations(badInst->getDebugLocation()).getLocation();
+  if (loc.isNull()) {
+    // If we have important clarifying information, make sure to emit it.
+    if (reason == UnknownReason::Default || fallbackLoc.isNull())
+      return false;
+    loc = fallbackLoc;
+  }
+
+  auto &module = badInst->getModule();
+  diagnose(module.getASTContext(), loc.getSourceLoc(), diag::tf_op_misuse_note,
+           error)
+      .highlight(loc.getSourceRange());
+  return true;
+}
+
 /// Given that this is an 'Unknown' value, emit diagnostic notes providing
 /// context about what the problem is.
 void SymbolicValue::emitUnknownDiagnosticNotes(SILLocation fallbackLoc) {
-  std::pair<SILNode *, UnknownReason> unknown = getUnknownValue();
-  auto badInst = dyn_cast<SILInstruction>(unknown.first);
+  auto badInst = dyn_cast<SILInstruction>(getUnknownNode());
   if (!badInst)
     return;
 
   std::string error;
-  switch (unknown.second) {
+  switch (getUnknownReason()) {
   case UnknownReason::Default:
     error = "could not fold operation";
     break;
@@ -779,17 +879,27 @@ void SymbolicValue::emitUnknownDiagnosticNotes(SILLocation fallbackLoc) {
     break;
   }
 
-  auto &module = badInst->getModule();
+  bool emittedFirstNote =
+      emitNoteDiagnostic(badInst, getUnknownReason(), fallbackLoc, error);
 
-  auto loc = skipInternalLocations(badInst->getDebugLocation()).getLocation();
-  if (loc.isNull()) {
-    // If we have important clarifying information, make sure to emit it.
-    if (unknown.second == UnknownReason::Default || fallbackLoc.isNull())
-      return;
-    loc = fallbackLoc;
+  auto &module = badInst->getModule();
+  auto &SM = module.getASTContext().SourceMgr;
+  unsigned originalDiagnosticLineNumber =
+      SM.getLineNumber(fallbackLoc.getSourceLoc());
+  for (auto &sourceLoc : llvm::reverse(getUnknownCallStack())) {
+    // Skip known sources.
+    if (!sourceLoc.isValid())
+      continue;
+    // Also skip notes that point to the same line as the original error, for
+    // example in:
+    //   #assert(foo(bar()))
+    // it is not useful to get three diagnostics referring to the same line.
+    if (SM.getLineNumber(sourceLoc) == originalDiagnosticLineNumber)
+      continue;
+
+    auto diag = emittedFirstNote ? diag::constexpr_called_from
+                                 : diag::constexpr_not_evaluable;
+    diagnose(module.getASTContext(), sourceLoc, diag);
+    emittedFirstNote = true;
   }
-
-  diagnose(module.getASTContext(), loc.getSourceLoc(), diag::tf_op_misuse_note,
-           error)
-      .highlight(loc.getSourceRange());
 }