@@ -36,13 +36,7 @@ predicate isInTypeContext(Expr expr) {
   or
   expr.getParent() instanceof TypeConstraint
   or
-  exists(Identifier id | id = NameBinding::getStaticBindingTargetFromRef(expr) |
-    id = any(ClassLikeDeclaration c).getNameNode()
-    or
-    id = any(TypeAliasDeclaration t).getNameNode()
-    or
-    id = any(TypeParameter t).getNameNode()
-  )
+  exists(NameBinding::getTypeFromRef(expr))
   or
   any(ExprPositionsPlugin p).isInTypeContext(expr)
   or
 
@@ -810,6 +810,22 @@ NameBinding getStaticBindingTargetFromRef(AstNode access) {
   result = getStaticBindingTargetFromIdentifier(getIdentifierFromRef(access))
 }
 
+/**
+ * Gets the type being accessed by `access`, if any.
+ */
+Identifier getTypeFromRef(AstNode access) {
+  result = getStaticBindingTargetFromRef(access) and
+  (
+    result = any(ClassLikeDeclaration c | not c instanceof EnumCaseClass).getNameNode()
+    or
+    result = any(TypeAliasDeclaration t).getNameNode()
+    or
+    result = any(TypeParameter t).getNameNode()
+    or
+    result = any(AssociatedTypeDeclaration t).getNameNode()
+  )
+}
+
 /**
  * Gets the name of the implicit receiver parameter in scope at `callable` (possibly declared by an outer callable).
  *
 
@@ -80,6 +80,8 @@ abstract private class TypeImpl extends TType {
    */
   TypeParameter getATypeParameter() { result = this.getPositionalTypeParameter(_) }
 
+  abstract Identifier getNameNode();
+
   /** Gets a textual representation of this type. */
   abstract string toString();
 
@@ -99,6 +101,8 @@ class ClassLikeDeclarationType extends TypeImpl, TClassLikeDeclarationType {
 
   string getName() { result = c.getName() }
 
+  override Identifier getNameNode() { result = c.getNameNode() }
+
   override TypeParameter getPositionalTypeParameter(int i) {
     result = TTypeParameterType(c.getTypeParameter(i))
   }
@@ -117,7 +121,9 @@ class ClassLikeDeclarationType extends TypeImpl, TClassLikeDeclarationType {
 /**
  * A pseudo type that does not correspond to any concrete type in the source code.
  */
-abstract class PseudoType extends TypeImpl { }
+abstract class PseudoType extends TypeImpl {
+  override Identifier getNameNode() { none() }
+}
 
 /**
  * A type representing an unknown type.
@@ -173,6 +179,8 @@ class TypeParameterType extends TypeParameter, TTypeParameterType {
 
   override ClassLikeDeclaration getDeclaringItem() { typeParam = result.getATypeParameter() }
 
+  override Identifier getNameNode() { result = typeParam.getNameNode() }
+
   override string toString() { result = typeParam.getName() }
 
   override Location getLocation() { result = typeParam.getLocation() }
@@ -192,6 +200,8 @@ class AssociatedTypeParameterType extends TypeParameter, TAssociatedTypeParamete
 
   override ClassLikeDeclaration getDeclaringItem() { result = c }
 
+  override Identifier getNameNode() { result = assocTypeDecl.getNameNode() }
+
   override string toString() {
     if inherited = true
     then result = assocTypeDecl.getName() + " (inherited)"
@@ -213,6 +223,8 @@ class UnknownTypeTypeParameter extends TypeParameter, TUnknownTypeTypeParameter
 
   override AstNode getDeclaringItem() { none() }
 
+  override Identifier getNameNode() { none() }
+
   override TypeParameter getPositionalTypeParameter(int j) { none() }
 
   override string toString() { result = "unknown type parameter " + i }
 
@@ -135,7 +135,11 @@ module Input3 implements InputSig3 {
   class AstNode = Unified::AstNode;
 
   class Expr extends Unified::Expr {
-    Expr() { isInAssignmentContext(this, _) or hasResultValue(this) }
+    Expr() {
+      isInAssignmentContext(this, _) or
+      hasResultValue(this) or
+      this = Construction::getSyntheticConstructionReceiver(_)
+    }
   }
 
   class Cast extends Expr, TypeCastExpr {
@@ -270,6 +274,7 @@ module Input3 implements InputSig3 {
 
   pragma[nomagic]
   private predicate lookupMember0(MemberAccessExpr mae, ClassLikeDeclaration cls, string name) {
+    not exists(getStaticBindingTargetFromRef(mae)) and // if a static member can be resolved, use it
     cls = inferType(mae.getBase()).(ClassLikeDeclarationType).getClassLikeDeclaration() and
     name = mae.getMemberName()
   }
@@ -393,12 +398,7 @@ module Input3 implements InputSig3 {
       )
     }
 
-    override TypeMention getType() {
-      result = c.getReturnType()
-      or
-      c instanceof ConstructorDeclaration and
-      result = this.getDeclaringType()
-    }
+    override TypeMention getType() { result = c.getReturnType() }
 
     override Identifier getNameNode() {
       result = c.(AccessorDeclaration).getNameNode()
@@ -456,26 +456,29 @@ module Input3 implements InputSig3 {
 
   class InvocationResolutionContext = Unit;
 
+  private TypeMention getQualifierTypeMention(CallExpr ce) {
+    result = ce.getCallee()
+    or
+    not ce.getCallee() instanceof TypeMention and
+    result = ce.getCallee().(MemberAccessExpr).getBase()
+  }
+
   class Invocation extends Expr, CallExpr {
-    Type getTypeQualifier(TypePath path) {
-      exists(TypeMention tm | result = tm.getTypeAt(path) |
-        tm = super.getCallee()
-        or
-        not super.getCallee() instanceof TypeMention and
-        tm = super.getCallee().(MemberAccessExpr).getBase()
-      )
-    }
+    Type getTypeQualifier(TypePath path) { result = getQualifierTypeMention(this).getTypeAt(path) }
 
     Type getTypeArgument(int i, TypePath path) { none() }
 
-    int getNumberOfArguments() { result = CallExpr.super.getNumberOfArguments() + 1 }
-
     Expr getArgument(int i) {
       i = 0 and
-      exists(boolean isFunctionExprInvoke | exists(this.getTargetImpl(isFunctionExprInvoke)) |
-        if isFunctionExprInvoke = true
-        then result = CallExpr.super.getCallee()
-        else result = CallExpr.super.getCallee().(MemberAccessExpr).getBase()
+      (
+        result = Construction::getSyntheticConstructionReceiver(this)
+        or
+        not exists(Construction::getSyntheticConstructionReceiver(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()
@@ -488,13 +491,13 @@ module Input3 implements InputSig3 {
       result = getFunctionInvoke(t)
     }
 
-    private Callable getTargetViaStaticNameBinding() {
+    Callable getTargetViaStaticNameBinding() {
       exists(NameBinding b | b = getStaticBindingTargetFromRef(this.getCallee()) |
         // object creation (including enum constructors): `String(42)`, `Optional.Some(42)`
-        exists(ClassLikeDeclaration cls, ConstructorDeclaration init |
+        exists(ClassLikeDeclaration cls |
           cls.getNameNode() = b and
-          init = cls.getAMember() and
-          result.asCallable() = init
+          result.isInstanceMemberOf(cls, _) and
+          result.asCallable() instanceof ConstructorDeclaration
         )
         or
         // call without explicit receiver: `foo(42)`
@@ -535,13 +538,13 @@ module Input3 implements InputSig3 {
         result = inferType(invocation.(CallExpr).getCallee(), path)
         or
         exists(TypePath prefix, TypePath suffix, int j |
-          functionInvokeSignature(t, invocation.getNumberOfArguments() - 1, j, i, prefix) and
+          functionInvokeSignature(t, invocation.getNumberOfArguments(), j, i, prefix) and
           result = inferType(invocation.getArgument(j + 1), suffix) and
           path = prefix.append(suffix)
         )
       )
       or
-      // A call to a regular function or method
+      // A non-function-expression call
       exists(invocation.getTargetImpl(false)) and
       (
         result = inferType(invocation.getArgument(i), path)
@@ -612,6 +615,144 @@ module Input3 implements InputSig3 {
       )
   }
 
+  predicate stepLanguageSpecificExtra(AstNode n1, TypePath prefix1, AstNode n2, TypePath prefix2) {
+    Construction::step(n1, prefix1, n2, prefix2)
+  }
+
+  /**
+   * 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
+   * methods:
+   *
+   * ```swift
+   * class A<Ta> {
+   *   init(x : Ta) { ... }
+   * }
+   *
+   * class B<Tb> : A<Tb?> { }
+   *
+   * A.init(0);        // (1) has type `A<Int>`
+   * B.init(.some(0)); // (2) has type `B<Int>`
+   * B<Int>(.none);    // (3) has type `B<Int>`
+   * ```
+   *
+   * Because the constructor calls are treated as normal instance method calls,
+   * we use the type qualifier to represent the receiver, and then allow for
+   * contextual type information to flow into the receiver:
+   *
+   * (1) The receiver has type `A`, `Ta` is inferred to be instantiated to `Int`,
+   *     which is propagated directly back into the receiver.
+   * (2) The receiver has type `B`, `Ta` is inferred to be instantiated to `Int?`
+   *     which in turn means `Tb` is inferred to be instantiated to `Int`, which
+   *     is then propagated back into the receiver.
+   * (3) The receiver has type `B<Int>`, and no further type inference is needed.
+   */
+  private module Construction {
+    /**
+     * Gets the AST node that is used to represent the receiver in a constructor
+     * invocation without an actual receiver.
+     */
+    TypeMention getSyntheticConstructionReceiver(Invocation invocation) {
+      invocation.getTargetViaStaticNameBinding().asCallable() instanceof ConstructorDeclaration and
+      result = getQualifierTypeMention(invocation)
+    }
+
+    private predicate constructionReceiver(Invocation i, ConstructorDeclaration cd, Expr receiver) {
+      cd = i.getTargetImpl(_).asCallable() and
+      receiver = i.getArgument(0)
+    }
+
+    /**
+     * Since we handle constructors as instance methods without return types,
+     * we need to explicitly handle constructors where (parts of) the type of
+     * the constructed object must be inferred from the context.
+     *
+     * Example:
+     *
+     * ```swift
+     * class C<T1, T2> {
+     *   init(x : T1) { ... } // `T2` must be inferred from the context
+     * }
+     * ```
+     */
+    private module ContextualConstructorReturnTypeInput implements
+      M3::ContextualTyping::ContextualReturnTypeInputSig
+    {
+      predicate callableHasTypeParameterAtReturnType(Callable c, TypePath path, TypeParameter tp) {
+        c.asCallable() instanceof ConstructorDeclaration and
+        tp = c.getDeclaringType().getTypeAt(path)
+      }
+
+      Parameter getACallableParameter(Callable c) {
+        result = c.getParameter(_) and
+        not result.getParameterEx().isImplicitReceiverParameter(_)
+      }
+    }
+
+    private module ContextualConstructorReturnType =
+      M3::ContextualTyping::ContextualReturnType<ContextualConstructorReturnTypeInput>;
+
+    private predicate needsContextualTyping(Invocation i, TypePath path) {
+      exists(
+        ConstructorDeclaration cd, Expr receiver, ClassLikeDeclaration declType, TypePath path0
+      |
+        constructionReceiver(i, cd, receiver) and
+        declType = inferType(receiver).(ClassLikeDeclarationType).getClassLikeDeclaration() and
+        ContextualConstructorReturnType::needsContextualTyping(i, path0)
+      |
+        declType.getAMember() = cd and
+        path = path0
+        or
+        // inherited constructor
+        exists(TypeAbstraction abs, TypeMention constraint, TypeParameter tp |
+          BaseTypes::rootTypesSatisfaction(TClassLikeDeclarationType(declType), _, abs, _,
+            constraint) and
+          BaseTypes::conditionSatisfiesConstraintTypeAt(abs, _, constraint, path0, tp) and
+          path = TypePath::singleton(tp)
+        )
+      )
+    }
+
+    /**
+     * Propagate type information from the receiver of a construction to the construction
+     * itself.
+     *
+     * Note that this works both for calls with synthetic receivers, `A.init(0)` or `A(0)`,
+     * as well as calls receivers, `self.init(0)` or `super.init(0)`.
+     */
+    predicate step(AstNode n1, TypePath prefix1, AstNode n2, TypePath prefix2) {
+      constructionReceiver(n2, _, n1) and
+      prefix1.isEmpty() and
+      prefix2.isEmpty()
+    }
+
+    Type inferType(AstNode n, TypePath path) {
+      n =
+        any(TypeMention tm |
+          tm = getSyntheticConstructionReceiver(_) and
+          result = tm.getTypeAt(path)
+        )
+      or
+      needsContextualTyping(n, path) and
+      result instanceof UnknownType
+    }
+
+    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 = getSyntheticConstructionReceiver(_) and
+      exists(TypePath prefix, Type t, TypeParameter tp |
+        t = tm.getTypeAt(prefix) and
+        not t instanceof UnknownType and
+        tp = t.getATypeParameter() and
+        path = TypePath::snoc(prefix, tp) and
+        not exists(tm.getTypeAt(path))
+      )
+    }
+  }
+
   Type inferTypeLanguageSpecific(AstNode n, TypePath path) {
     result = Plugin::inferType(n, path)
     or
@@ -650,10 +791,16 @@ module Input3 implements InputSig3 {
     n.(ArrayLiteral).getNumberOfElements() = 0 and
     path = TypePath::singleton(getArrayElementTypeParameter()) and
     result instanceof UnknownType
+    or
+    result = Construction::inferType(n, path)
   }
 
   pragma[nomagic]
   Type inferTypeCertainLanguageSpecific(AstNode n, TypePath path) { none() }
+
+  predicate allowFullContextualInference(AstNode n, TypePath path) {
+    Construction::allowFullContextualInference(n, path)
+  }
 }
 
 private module M3 = Make3<Input3>;