Don't enforce (normal) emission for pragma(inline, true) function templates

Debugging failing fail_compilation/ice19762.d (stack overflow in LDC)
was a trip down the rabbit hole.

By the looks of it, the root of all evil is again the frontend not
properly validating IndexExpressions - this time, for structs with fwd-
referencing errors (analogous to the problem for opaque structs with
compilable/ice20044.d, see https://issues.dlang.org/show_bug.cgi?id=20959).

The stack overflow happens in LLVM when trying to create a GEP for
core.internal.array.equality.at(), when checking the struct element type
(with cycles, i.e., containing a field of itself) for sizedness. This
little function now uses `pragma(inline, true)`, so it was newly
codegen'd although needsCodegen() returns false.

With the new available_externally emission into each referencing CU, I
think this enforced regular emission from the module members tree
shouldn't be required anymore, allowing to work around the test
regression and possibly more issues with speculative instantiations.

After adapting the codegen/inlining_templates.d lit-test accordingly (no
IR definitions anymore in .ll file, because available_externally doesn't
make it there), I've noticed that a lambda in imported and inlined
call_enforce_with_default_template_params() wasn't emitted - it got
culled by alreadyOrWillBeDefined().
Function/delegate literals aren't culled anymore.

Author: kinke

gen/declarations.cpp

@@ -371,28 +371,19 @@ class CodegenVisitor : public Visitor {
       return;
     }
 
-    // Force codegen if this is a templated function with pragma(inline, true).
-    if ((decl->members->length == 1) &&
-        ((*decl->members)[0]->isFuncDeclaration()) &&
-        ((*decl->members)[0]->isFuncDeclaration()->inlining == PINLINEalways)) {
-      Logger::println("needsCodegen() == false, but function is marked with "
-                      "pragma(inline, true), so it really does need "
-                      "codegen.");
-    } else {
-      // FIXME: This is #673 all over again.
-      if (!decl->needsCodegen()) {
-        Logger::println("Does not need codegen, skipping.");
-        return;
-      }
+    // FIXME: This is #673 all over again.
+    if (!decl->needsCodegen()) {
+      Logger::println("Does not need codegen, skipping.");
+      return;
+    }
 
-      if (irs->dcomputetarget && (decl->tempdecl == Type::rtinfo ||
-                                  decl->tempdecl == Type::rtinfoImpl)) {
-        // Emitting object.RTInfo(Impl) template instantiations in dcompute
-        // modules would require dcompute support for global variables.
-        Logger::println("Skipping object.RTInfo(Impl) template instantiations "
-                        "in dcompute modules.");
-        return;
-      }
+    if (irs->dcomputetarget && (decl->tempdecl == Type::rtinfo ||
+                                decl->tempdecl == Type::rtinfoImpl)) {
+      // Emitting object.RTInfo(Impl) template instantiations in dcompute
+      // modules would require dcompute support for global variables.
+      Logger::println("Skipping object.RTInfo(Impl) template instantiations "
+                      "in dcompute modules.");
+      return;
     }
 
     for (auto &m : *decl->members) {

gen/function-inlining.cpp

@@ -73,6 +73,9 @@ bool isInlineCandidate(FuncDeclaration &fdecl) {
 } // end anonymous namespace
 
 bool alreadyOrWillBeDefined(FuncDeclaration &fdecl) {
+  if (fdecl.isFuncLiteralDeclaration()) // emitted into each referencing CU
+    return true;
+
   for (FuncDeclaration *f = &fdecl; f;) {
     if (!f->isInstantiated() && f->inNonRoot()) {
       return false;

tests/codegen/inlining_templates.d

@@ -31,10 +31,8 @@ void main()
 {
 }
 
-// CHECK-NOT: declare{{.*}}_D6inputs10inlinables__T12template_fooTiZQrUNaNbNiNfiZi
-// CHECK-NOT: declare{{.*}}_D3std9exception__T7enforce
+// CHECK-NOT: declare {{.*}}template_foo
 
-// CHECK-DAG: define{{.*}}_D6inputs10inlinables__T12template_fooTiZQrUNaNbNiNfiZi{{.*}}) #[[ATTR:[0-9]+]]
-// CHECK-DAG: define{{.*}}_D3std9exception__T7enforce{{.*}}) #[[ATTR]]
-
-// CHECK-DAG: attributes #[[ATTR]] ={{.*}} alwaysinline
+// CHECK-NOT: declare {{.*}}call_enforce_with_default_template_params
+// CHECK-NOT: declare {{.*}}__lambda
+// CHECK-NOT: declare {{.*}}_D3std9exception__T7enforce