Eagerly emit getters at Onone.

Force SILGen to also eagerly emit getters when compiling at Onone. The
reason for this is that getters (even not user-written ones, generated
by result builders) can, and are often called by users debugging swift
programs, and should be available for that reason.

rdar://133329303

Author: augusto2112

include/swift/SIL/SILDeclRef.h

@@ -576,6 +576,9 @@ struct SILDeclRef {
   /// for e.g a lazy variable getter.
   bool hasUserWrittenCode() const;
 
+  /// True  if the referenced entity is a getter function.
+  bool isGetter() const;
+
   /// Return the scope in which the parent class of a method (i.e. class
   /// containing this declaration) can be subclassed, returning NotApplicable if
   /// this is not a method, there is no such class, or the class cannot be

lib/SIL/IR/SILDeclRef.cpp

@@ -387,6 +387,12 @@ bool SILDeclRef::hasUserWrittenCode() const {
   llvm_unreachable("Unhandled case in switch!");
 }
 
+bool SILDeclRef::isGetter() const {
+  if (auto *accessor = dyn_cast_or_null<AccessorDecl>(getFuncDecl()))
+    return accessor->isGetter();
+  return false;
+}
+
 namespace {
 enum class LinkageLimit {
   /// No limit.

lib/SILGen/SILGen.cpp

@@ -1197,9 +1197,16 @@ void SILGenModule::emitOrDelayFunction(SILDeclRef constant) {
 
   auto emitAfter = lastEmittedFunction;
 
+  // When compiling at Onone, getters shouldn't be delayed, even if they don't
+  // have user written code because they can still be accessible in the
+  // debugger.
+  bool isOnoneGetter =
+      constant.isGetter() &&
+      M.getOptions().OptMode == OptimizationMode::NoOptimization;
+
   // Implicit decls may be delayed if they can't be used externally.
   auto linkage = constant.getLinkage(ForDefinition);
-  bool mayDelay = !constant.hasUserWrittenCode() &&
+  bool mayDelay = !isOnoneGetter && !constant.hasUserWrittenCode() &&
                   !constant.isDynamicallyReplaceable() &&
                   !isPossiblyUsedExternally(linkage, M.isWholeModule());
 

test/IRGen/preserve_for_debugger.swift

@@ -55,6 +55,8 @@ class Baz: Foo {
 
 struct Qux {
   @Bar(wrappedValue: Baz()) private var baz: Baz
+  // Baz instance that is never accessed.
+  @Bar(wrappedValue: Baz()) private var baz2: Baz
 
     func f() {
         print(self.baz) // break here
@@ -64,3 +66,4 @@ let qux = Qux()
 qux.f()
 
 // CHECK: !DISubprogram(name: "baz.get"
+// CHECK: !DISubprogram(name: "baz2.get"