[Sema] Dig out other constructor if call is wrapped in a Dot-Call

Guessing this bug /feature is introduced in CSApply ExprRewriter::buildMemberRef
but didn't dig deep enough to find there. If a derived class' designated initializer
initializes all stored let properties before calling super.init(), we don't properly
type-check the chained init call. This does not happen if the stored properties are
var or default initialized. We can however dig the OtherConstructorDeclRefExpr out of
the semanticFn of the DotSyntaxCallExpr and proceed as normal.

Author: Adam Cmiel

lib/Sema/TypeCheckStmt.cpp

@@ -2163,11 +2163,15 @@ static Expr* constructCallToSuperInit(ConstructorDecl *ctor,
 /// \returns true if an error occurred.
 static bool checkSuperInit(ConstructorDecl *fromCtor,
                            ApplyExpr *apply, bool implicitlyGenerated) {
+  auto Callee = apply->getSemanticFn();
+  if (auto dotCall = dyn_cast<DotSyntaxCallExpr>(Callee))
+    Callee = dotCall->getSemanticFn();
+
   // Make sure we are referring to a designated initializer.
-  auto otherCtorRef = dyn_cast<OtherConstructorDeclRefExpr>(
-                        apply->getSemanticFn());
-  if (!otherCtorRef)
+  auto otherCtorRef = dyn_cast<OtherConstructorDeclRefExpr>(Callee);
+  if (!otherCtorRef) {
     return false;
+  }
 
   auto ctor = otherCtorRef->getDecl();
   if (!ctor->isDesignatedInit()) {

test/decl/func/complete_object_init.swift

@@ -4,7 +4,7 @@
 // Declaration of complete object initializers and basic semantic checking
 // ---------------------------------------------------------------------------
 class A {
-  convenience init(int i: Int) { // expected-note{{convenience initializer is declared here}}
+  convenience init(int i: Int) { // expected-note 5 {{convenience initializer is declared here}}
     self.init(double: Double(i))
   }
 
@@ -39,6 +39,38 @@ class DerivesA : A {
   }
 }
 
+// Fixing https://github.com/swiftlang/swift/issues/80311
+class DerivesAWithLet : A {
+  let str: String
+  init(int i: Int) {
+    str = "foo"
+    super.init(int: i) // expected-error{{must call a designated initializer of the superclass 'A'}}
+  }
+}
+
+class DerivesAWithVar : A {
+  var str: String
+  init(int i: Int) {
+    str = "foo"
+    super.init(int: i) // expected-error{{must call a designated initializer of the superclass 'A'}}
+  }
+}
+
+class DerivesAWithDefaultLet : A {
+  let str: String = "foo"
+  init(int i: Int) {
+    super.init(int: i) // expected-error{{must call a designated initializer of the superclass 'A'}}
+  }
+}
+
+class DerivesAWithDefaultVar : A {
+  var str: String = "foo"
+  init(int i: Int) {
+    super.init(int: i) // expected-error{{must call a designated initializer of the superclass 'A'}}
+  }
+}
+
+
 struct S {
   convenience init(int i: Int) { // expected-error{{initializers in structs are not marked with 'convenience'}}
     self.init(double: Double(i))