Parser: Don't skip functions with a nested typealias or actor for LLDB

The flag -experimental-skip-non-inlinable-function-bodies-without-types
is built in the emit-module-separately phase to quickly extract the API
of the target module. It is designed to not skip functions with nested
types as these are used by LLDB.

This logic relies on a simple heuristic to find nested type. Let's make
sure it detects tyealiases and actors.

rdar://120928396

Author: xymus

Diff for: lib/Parse/ParseDecl.cpp

@@ -5625,7 +5625,8 @@ static unsigned skipUntilMatchingRBrace(Parser &P,
       tok::pound_if, tok::pound_else, tok::pound_endif, tok::pound_elseif);
 
     HasNestedTypeDeclarations |= P.Tok.isAny(tok::kw_class, tok::kw_struct,
-                                             tok::kw_enum);
+                                             tok::kw_enum, tok::kw_typealias)
+                              || P.Tok.isContextualKeyword("actor");
 
     // HACK: Bail if we encounter what could potentially be a regex literal.
     // This is necessary as:

Diff for: test/Frontend/skip-function-bodies.swift

@@ -158,19 +158,20 @@ func funcPublicWithDefer() {
 // CHECK-SIL-SKIP-NONINLINE-OR-WITHOUTTYPES-NOT: "funcPublicWithDefer()"
 
 public func funcPublicWithNestedFuncAndTypealias() {
-  let NEVERTYPECHECK_outerLocal = "funcPublicWithNestedFuncAndTypealias()"
-  _blackHole(NEVERTYPECHECK_outerLocal)
+  let INLINENOTYPECHECK_outerLocal = "funcPublicWithNestedFuncAndTypealias()"
+  _blackHole(INLINENOTYPECHECK_outerLocal)
 
   typealias LocalType = Int
   func takesLocalType(_ x: LocalType) {
-    let NEVERTYPECHECK_innerLocal = "funcPublicWithNestedFuncAndTypealias()@takesLocalType(_:)"
-    _blackHole(NEVERTYPECHECK_innerLocal)
+    let INLINENOTYPECHECK_innerLocal = "funcPublicWithNestedFuncAndTypealias()@takesLocalType(_:)"
+    _blackHole(INLINENOTYPECHECK_innerLocal)
   }
   takesLocalType(0)
 }
 // CHECK-TEXTUAL-NOT: "funcPublicWithNestedFuncAndTypealias()"
 // CHECK-SIL-NO-SKIP: "funcPublicWithNestedFuncAndTypealias()"
-// CHECK-SIL-SKIP-NONINLINE-OR-WITHOUTTYPES-NOT: "funcPublicWithNestedFuncAndTypealias()"
+// CHECK-SIL-SKIP-WITHOUTTYPES: "funcPublicWithNestedFuncAndTypealias()"
+// CHECK-SIL-SKIP-NONINLINE-NOT: "funcPublicWithNestedFuncAndTypealias()"
 
 // CHECK-TEXTUAL-NOT: "funcPublicWithNestedFuncAndTypealias()@takesLocalType(_:)"
 // CHECK-SIL-NO-SKIP: "funcPublicWithNestedFuncAndTypealias()@takesLocalType(_:)"
@@ -196,6 +197,26 @@ public func funcPublicWithNestedTypeEnum() {
 // CHECK-SIL-SKIP-NONINLINE-NOT: "funcPublicWithNestedTypeEnum()"
 // CHECK-SIL-SKIP-WITHOUTTYPES: "funcPublicWithNestedTypeEnum()"
 
+public func funcPublicWithNestedTypealias() {
+  let INLINENOTYPECHECK_local = "funcPublicWithNestedTypealias()"
+  _blackHole(INLINENOTYPECHECK_local)
+  typealias TA = Int
+}
+// CHECK-TEXTUAL-NOT: "funcPublicWithNestedTypealias()"
+// CHECK-SIL-NO-SKIP: "funcPublicWithNestedTypealias()"
+// CHECK-SIL-SKIP-NONINLINE-NOT: "funcPublicWithNestedTypealias()"
+// CHECK-SIL-SKIP-WITHOUTTYPES: "funcPublicWithNestedTypealias()"
+
+public func funcPublicWithNestedTypeActor() {
+  let INLINENOTYPECHECK_local = "funcPublicWithNestedTypeActor()"
+  _blackHole(INLINENOTYPECHECK_local)
+  actor A {}
+}
+// CHECK-TEXTUAL-NOT: "funcPublicWithNestedTypeActor()"
+// CHECK-SIL-NO-SKIP: "funcPublicWithNestedTypeActor()"
+// CHECK-SIL-SKIP-NONINLINE-NOT: "funcPublicWithNestedTypeActor()"
+// CHECK-SIL-SKIP-WITHOUTTYPES: "funcPublicWithNestedTypeActor()"
+
 public func funcPublicWithNestedTypeStruct() {
   let INLINENOTYPECHECK_local = "funcPublicWithNestedTypeStruct()"
   _blackHole(INLINENOTYPECHECK_local)