@@ -138,8 +138,7 @@ module Input3 implements InputSig3 {
     Expr() {
       isInAssignmentContext(this, _) or
       hasResultValue(this) or
-      this = any(CallExpr ce).getCallee() or
-      this = any(Expr e).(MemberAccessExpr).getBase()
+      this = Construction::getConstructionReceiver(_)
     }
   }
 
@@ -455,31 +454,31 @@ module Input3 implements InputSig3 {
 
   Callable getEnclosingCallable(AstNode node) { result.asCallable() = node.getEnclosingCallable() }
 
-  private newtype CallKind =
-    Invoke() or
-    Constructor() or
-    Ordinary()
-
   class InvocationResolutionContext = Unit;
 
-  class Invocation extends Expr, CallExpr {
-    TypeMention getReceiverTypeMention() {
-      result = super.getCallee()
-      or
-      not super.getCallee() instanceof TypeMention and
-      result = super.getCallee().(MemberAccessExpr).getBase()
-    }
+  private TypeMention getQualifierTypeMention(CallExpr ce) {
+    result = ce.getCallee()
+    or
+    not ce.getCallee() instanceof TypeMention and
+    result = ce.getCallee().(MemberAccessExpr).getBase()
+  }
 
-    Type getTypeQualifier(TypePath path) { result = this.getReceiverTypeMention().getTypeAt(path) }
+  class Invocation extends Expr, CallExpr {
+    Type getTypeQualifier(TypePath path) { result = getQualifierTypeMention(this).getTypeAt(path) }
 
     Type getTypeArgument(int i, TypePath path) { none() }
 
     Expr getArgument(int i) {
       i = 0 and
-      exists(CallKind kind | exists(this.getTargetImpl(kind)) |
-        if kind = [Invoke().(CallKind), Constructor()]
-        then result = CallExpr.super.getCallee()
-        else result = CallExpr.super.getCallee().(MemberAccessExpr).getBase()
+      (
+        result = Construction::getConstructionReceiver(this)
+        or
+        not exists(Construction::getConstructionReceiver(this)) and
+        exists(boolean isFunctionExprInvoke | exists(this.getTargetImpl(isFunctionExprInvoke)) |
+          if isFunctionExprInvoke = true
+          then result = CallExpr.super.getCallee()
+          else result = CallExpr.super.getCallee().(MemberAccessExpr).getBase()
+        )
       )
       or
       result = CallExpr.super.getArgument(i - 1).getValue()
@@ -492,41 +491,40 @@ module Input3 implements InputSig3 {
       result = getFunctionInvoke(t)
     }
 
-    Callable getTargetViaStaticNameBinding(CallKind kind) {
+    Callable getTargetViaStaticNameBinding() {
       exists(NameBinding b | b = getStaticBindingTargetFromRef(this.getCallee()) |
         // object creation (including enum constructors): `String(42)`, `Optional.Some(42)`
         exists(ClassLikeDeclaration cls |
           cls.getNameNode() = b and
           result.isInstanceMemberOf(cls, _) and
-          result.asCallable() instanceof ConstructorDeclaration and
-          kind = Constructor()
+          result.asCallable() instanceof ConstructorDeclaration
         )
         or
         // call without explicit receiver: `foo(42)`
-        result.getNameNode() = b and
-        kind = Ordinary()
+        result.getNameNode() = b
       )
     }
 
-    Callable getTargetImpl(CallKind kind) {
+    Callable getTargetImpl(boolean isFunctionExprInvoke) {
       // mutual recursion; call with explicit receiver: `obj.foo(42)`
       result = lookupInstanceMember(this.getCallee()) and
-      kind = Ordinary()
+      isFunctionExprInvoke = false
       or
       // mutual recursion; call to a function expression: `callback(42)`
       result.asCallable() = this.getInvokeTarget(_) and
-      kind = Invoke()
+      isFunctionExprInvoke = true
       or
       // no mutual recursion; can be resolved directly with static name binding
-      result = this.getTargetViaStaticNameBinding(kind)
+      result = this.getTargetViaStaticNameBinding() and
+      isFunctionExprInvoke = false
     }
 
     Callable getTarget(InvocationResolutionContext c) {
       result = this.getTargetImpl(_) and
       exists(c)
     }
 
-    Callable getATargetForTypeQualifierMatching() { result = this.getTargetViaStaticNameBinding(_) }
+    Callable getATargetForTypeQualifierMatching() { result = this.getTargetViaStaticNameBinding() }
   }
 
   Type inferInvocationArgumentType(
@@ -547,10 +545,8 @@ module Input3 implements InputSig3 {
       )
       or
       // A non-function-expression call
-      exists(CallKind kind |
-        exists(invocation.getTargetImpl(kind)) and
-        kind != Invoke()
-      |
+      exists(invocation.getTargetImpl(false)) and
+      (
         result = inferType(invocation.getArgument(i), path)
         or
         i = 0 and
@@ -620,7 +616,7 @@ module Input3 implements InputSig3 {
   }
 
   /**
-   * Provides logic for resolving the types of constructor invocations.
+   * Provides logic for resolving types of constructor invocations.
    *
    * Constructors are treated as instance methods without return types, in order
    * to be able to handle inherited constructors similar to ordinary instance
@@ -650,11 +646,26 @@ module Input3 implements InputSig3 {
    * (3) The receiver has type `B<Int>`, and no further type inference is needed.
    */
   private module Construction {
-    private TypeMention getAReceiverTypeMention() {
-      exists(Invocation invocation |
-        invocation.getTargetViaStaticNameBinding(_).asCallable() instanceof ConstructorDeclaration and
-        result = invocation.getReceiverTypeMention()
-      )
+    /**
+     * Gets the AST node that is used to represent the receiver in a constructor
+     * invocation.
+     */
+    TypeMention getConstructionReceiver(Invocation invocation) {
+      invocation.getTargetViaStaticNameBinding().asCallable() instanceof ConstructorDeclaration and
+      result = getQualifierTypeMention(invocation)
+    }
+
+    /**
+     * Gets the inferred type at `path` of the object constructed at `i` using constructor
+     * `cd`. Because of how we handle constructors as instance methods without return types,
+     * this is simply the inferred type of the receiver.
+     *
+     * Note that this works for both calls without an actual receiver, `A.init(0)` or `A(0)`,
+     * as well as calls with a receiver, `self.init(0)` or `super.init(0)`.
+     */
+    private Type inferConstructionType(Invocation i, ConstructorDeclaration cd, TypePath path) {
+      cd = i.getTargetImpl(_).asCallable() and
+      result = inferType(i.getArgument(0), path)
     }
 
     /**
@@ -687,16 +698,6 @@ module Input3 implements InputSig3 {
     private module ContextualConstructorReturnType =
       M3::ContextualTyping::ContextualReturnType<ContextualConstructorReturnTypeInput>;
 
-    /**
-     * Gets the inferred type at `path` of the object constructed at `i` using constructor
-     * `cd`. Because of how we handle constructors as instance methods without return types,
-     * this is simply the inferred type of the receiver.
-     */
-    private Type inferConstructionType(Invocation i, ConstructorDeclaration cd, TypePath path) {
-      cd = i.getTargetImpl(_).asCallable() and
-      result = inferType(i.getArgument(0), path)
-    }
-
     private predicate needsContextualTyping(Invocation i, TypePath path) {
       exists(ConstructorDeclaration cd, ClassLikeDeclaration declType, TypePath path0 |
         declType =
@@ -719,11 +720,11 @@ module Input3 implements InputSig3 {
     }
 
     Type inferConstructionType(AstNode n, TypePath path) {
-      exists(TypeMention tm |
-        n = tm and
-        tm = getAReceiverTypeMention() and
-        result = tm.getTypeAt(path)
-      )
+      n =
+        any(TypeMention tm |
+          tm = getConstructionReceiver(_) and
+          result = tm.getTypeAt(path)
+        )
       or
       result = inferConstructionType(n, _, path)
       or
@@ -734,7 +735,7 @@ module Input3 implements InputSig3 {
     predicate allowFullContextualInference(TypeMention tm, TypePath path) {
       // For a construction such as `Optional.some(0)`, we need contextual inference
       // to infer the type of the wrapped object
-      tm = getAReceiverTypeMention() and
+      tm = getConstructionReceiver(_) and
       exists(TypePath prefix, Type t, TypeParameter tp |
         t = tm.getTypeAt(prefix) and
         not t instanceof UnknownType and