Merge pull request swiftlang#27942 from ravikandhadai/oslog-append-interpolation-consteval-improved

Author: swift-ci

include/swift/AST/DiagnosticsSIL.def

@@ -408,11 +408,17 @@ NOTE(constexpr_unsupported_instruction_found_here,none, "operation"
 
 NOTE(constexpr_found_callee_with_no_body, none,
     "encountered call to '%0' whose body is not available. "
-    "Imported functions must be marked '@inlinable' to constant evaluate.",
+    "Imported functions must be marked '@inlinable' to constant evaluate",
     (StringRef))
 NOTE(constexpr_callee_with_no_body, none,
     "%select{|calls a }0function whose body is not available", (bool))
 
+NOTE(constexpr_found_call_with_unknown_arg, none,
+    "encountered call to '%0' where the %1 argument is not a constant",
+    (StringRef, StringRef))
+NOTE(constexpr_call_with_unknown_arg, none,
+    "%select{|makes a }0function call with non-constant arguments", (bool))
+
 NOTE(constexpr_untracked_sil_value_use_found, none,
     "encountered use of a variable not tracked by the evaluator", ())
 NOTE(constexpr_untracked_sil_value_used_here, none,
@@ -509,24 +515,23 @@ NOTE(try_branch_doesnt_yield, none, "missing yield when error is "
 
 // OS log optimization diagnostics.
 
-ERROR(oslog_message_argument_not_found, none, "no argument of type %0 in "
-  " the os log call", (Identifier))
+ERROR(oslog_non_const_interpolation_options, none, "interpolation arguments "
+      "like format and privacy options must be constants", ())
 
-ERROR(oslog_dynamic_message, none, "os log methods must be passed a string "
-      "interpolation literal. 'OSLogMessage' must not be constructed explicitly",
-      ())
+ERROR(oslog_const_evaluable_fun_error, none, "evaluation of constant-evaluable "
+      "function '%0' failed", (StringRef))
 
-ERROR(oslog_const_evaluation_error, none, "constant evaluating 'OSLogMessage'"
-  "implementation failed.", ())
+ERROR(oslog_fail_stop_error, none, "constant evaluation of log call failed "
+      "with fatal error", ())
 
-ERROR(oslog_non_constant_message, none, "'OSLogMessage' struct is "
-      "unoptimizable: 'init' is not constant evaluable", ())
+ERROR(oslog_non_constant_message, none, "'OSLogMessage' instance passed to the "
+      "log call is not a constant", ())
 
-ERROR(oslog_non_constant_interpolation, none, "'OSLogInterpolation' struct is "
-      "unoptimizable: 'init' is not constant evaluable", ())
+ERROR(oslog_non_constant_interpolation, none, "'OSLogInterpolation' instance "
+      "passed to 'OSLogMessage.init' is not a constant", ())
 
 ERROR(oslog_property_not_constant, none, "'OSLogInterpolation.%0' is not a "
-      "constant: formatting and privacy options must be literals", (StringRef))
+      "constant", (StringRef))
 
 ERROR(global_string_pointer_on_non_constant, none, "globalStringTablePointer "
       "builtin must used only on string literals", ())

include/swift/SIL/SILConstants.h

@@ -107,6 +107,9 @@ class UnknownReason {
     /// Encountered an instruction not supported by the interpreter.
     UnsupportedInstruction,
 
+    /// Encountered a function call whose arguments are not constants.
+    CallArgumentUnknown,
+
     /// Encountered a function call where the body of the called function is
     /// not available.
     CalleeImplementationUnknown,
@@ -145,8 +148,9 @@ class UnknownReason {
 
   // Auxiliary information for different unknown kinds.
   union {
-    SILFunction *function;
-    const char *trapMessage;
+    SILFunction *function;   // For CalleeImplementationUnknown
+    const char *trapMessage; // For Trap.
+    unsigned argumentIndex;  // For CallArgumentUnknown
   } payload;
 
 public:
@@ -156,6 +160,7 @@ class UnknownReason {
     switch (kind) {
     case UnknownKind::CalleeImplementationUnknown:
     case UnknownKind::Trap:
+    case UnknownKind::CallArgumentUnknown:
       return true;
     default:
       return false;
@@ -200,6 +205,18 @@ class UnknownReason {
     assert(kind == UnknownKind::Trap);
     return payload.trapMessage;
   }
+
+  static UnknownReason createCallArgumentUnknown(unsigned argIndex) {
+    UnknownReason reason;
+    reason.kind = UnknownKind::CallArgumentUnknown;
+    reason.payload.argumentIndex = argIndex;
+    return reason;
+  }
+
+  unsigned getArgumentIndex() {
+    assert(kind == UnknownKind::CallArgumentUnknown);
+    return payload.argumentIndex;
+  }
 };
 
 /// This is the symbolic value tracked for each SILValue in a scope.  We

include/swift/SILOptimizer/Utils/ConstExpr.h

@@ -187,11 +187,6 @@ class ConstExprStepEvaluator {
 
   Optional<SymbolicValue> lookupConstValue(SILValue value);
 
-  /// Returns true if and only if `errorVal` denotes an error that requires
-  /// aborting interpretation and returning the error. Skipping an instruction
-  /// that produces such errors is not a valid behavior.
-  bool isFailStopError(SymbolicValue errorVal);
-
   /// Return the number of instructions evaluated for the last `evaluate`
   /// operation. This could be used by the clients to limit the number of
   /// instructions that should be evaluated by the step-wise evaluator.
@@ -212,7 +207,18 @@ class ConstExprStepEvaluator {
   void dumpState();
 };
 
+bool isConstantEvaluable(SILFunction *fun);
+
+/// Return true if and only if the given function \p fun is specially modeled
+/// by the constant evaluator. These are typically functions in the standard
+/// library, such as String.+=, Array.append, whose semantics is built into the
+/// evaluator.
 bool isKnownConstantEvaluableFunction(SILFunction *fun);
 
+/// Return true if and only if \p errorVal denotes an error that requires
+/// aborting interpretation and returning the error. Skipping an instruction
+/// that produces such errors is not a valid behavior.
+bool isFailStopError(SymbolicValue errorVal);
+
 } // end namespace swift
 #endif

lib/SIL/SILConstants.cpp

@@ -20,7 +20,7 @@ using namespace swift;
 
 namespace swift {
 llvm::cl::opt<unsigned>
-    ConstExprLimit("constexpr-limit", llvm::cl::init(1024),
+    ConstExprLimit("constexpr-limit", llvm::cl::init(2048),
                    llvm::cl::desc("Number of instructions interpreted in a"
                                   " constexpr function"));
 }
@@ -792,6 +792,12 @@ static void getWitnessMethodName(WitnessMethodInst *witnessMethodInst,
   }
 }
 
+/// A helper function to pretty print function names in diagnostics.
+static std::string demangleSymbolNameForDiagnostics(StringRef name) {
+  return Demangle::demangleSymbolAsString(
+      name, Demangle::DemangleOptions::SimplifiedUIDemangleOptions());
+}
+
 /// Given that this is an 'Unknown' value, emit diagnostic notes providing
 /// context about what the problem is. Specifically, point to interesting
 /// source locations and function calls in the call stack.
@@ -910,14 +916,30 @@ void SymbolicValue::emitUnknownDiagnosticNotes(SILLocation fallbackLoc) {
   case UnknownReason::CalleeImplementationUnknown: {
     SILFunction *callee = unknownReason.getCalleeWithoutImplmentation();
     std::string demangledCalleeName =
-        Demangle::demangleSymbolAsString(callee->getName());
+        demangleSymbolNameForDiagnostics(callee->getName());
     diagnose(ctx, diagLoc, diag::constexpr_found_callee_with_no_body,
              StringRef(demangledCalleeName));
     if (emitTriggerLocInDiag)
       diagnose(ctx, triggerLoc, diag::constexpr_callee_with_no_body,
                triggerLocSkipsInternalLocs);
     return;
   }
+  case UnknownReason::CallArgumentUnknown: {
+    unsigned argNumber = unknownReason.getArgumentIndex() + 1;
+    ApplyInst *call = dyn_cast<ApplyInst>(unknownNode);
+    assert(call);
+    SILFunction *callee = call->getCalleeFunction();
+    assert(callee);
+    std::string demangledCalleeName =
+        demangleSymbolNameForDiagnostics(callee->getName());
+    diagnose(ctx, diagLoc, diag::constexpr_found_call_with_unknown_arg,
+             demangledCalleeName,
+             (Twine(argNumber) + llvm::getOrdinalSuffix(argNumber)).str());
+    if (emitTriggerLocInDiag)
+      diagnose(ctx, triggerLoc, diag::constexpr_call_with_unknown_arg,
+               triggerLocSkipsInternalLocs);
+    return;
+  }
   case UnknownReason::UntrackedSILValue:
     diagnose(ctx, diagLoc, diag::constexpr_untracked_sil_value_use_found);
     if (emitTriggerLocInDiag)