@@ -138,6 +138,9 @@ module Public {
   final class EnumCaseClass extends ClassLikeDeclaration {
     EnumCaseClass() { this.hasModifier("enum_case") }
 
+    /** Gets the enum declaration that this case class belongs to. */
+    ClassLikeDeclaration getEnum() { this = result.getAMember() }
+
     /** Gets the constructor of this algebraic data type. */
     EnumCaseConstructor getConstructor() { result = this.getAMember() }
   }
@@ -168,5 +171,31 @@ module Public {
 
     /** Gets the class containing this constructor. */
     EnumCaseClass getEnumCaseClass() { result.getAMember() = this }
+
+    /** Gets the enum declaration that this constructor belongs to. */
+    ClassLikeDeclaration getEnum() { result = this.getEnumCaseClass().getEnum() }
+  }
+
+  /**
+   * A field of an enum case in an algebraic data type. For example `a` and
+   * `b` in
+   *
+   * ```swift
+   * enum E {
+   *   case a
+   *   case b
+   * }
+   * ```
+   */
+  final class EnumField extends VariableDeclaration {
+    private ClassLikeDeclaration enum;
+
+    EnumField() {
+      this = enum.getAMember() and
+      this.hasModifier("enum_case")
+    }
+
+    /** Gets the enum declaration that this enum field belongs to. */
+    ClassLikeDeclaration getEnum() { result = enum }
   }
 }
@@ -38,6 +38,12 @@ predicate associatedTypeParameterInherited(
   name = a.getName()
 }
 
+private predicate isNestedType(ClassLikeDeclaration nested, ClassLikeDeclaration parent) {
+  exists(nested.getNameNode()) and
+  exists(parent.getNameNode()) and
+  parent.getAMemberIncludingExtensions() = nested
+}
+
 cached
 newtype TType =
   TClassLikeDeclarationType(ClassLikeDeclaration c) {
@@ -56,6 +62,7 @@ newtype TType =
   ) {
     associatedTypeParameter(c, a, inherited)
   } or
+  TParentTypeParameterType(ClassLikeDeclaration c) { isNestedType(c, _) } or
   TUnknownType() or
   TUnknownTypeTypeParameter(int i) { i in [0 .. 20] }
 
@@ -112,9 +119,11 @@ class ClassLikeDeclarationType extends TypeImpl, TClassLikeDeclarationType {
     result = super.getATypeParameter()
     or
     result = TAssociatedTypeParameterType(c, _, _)
+    or
+    result = TParentTypeParameterType(c)
   }
 
-  override string toString() { result = c.getName() }
+  override string toString() { result = c.getQualifiedName() }
 
   override Location getLocation() { result = c.getLocation() }
 }
@@ -214,6 +223,25 @@ class AssociatedTypeParameterType extends TypeParameter, TAssociatedTypeParamete
   }
 }
 
+/**
+ * A special type parameter used to represent the parent type of a nested class.
+ */
+class ParentTypeParameterType extends TypeParameter, TParentTypeParameterType {
+  private Unified::ClassLikeDeclaration c;
+
+  ParentTypeParameterType() { this = TParentTypeParameterType(c) }
+
+  ClassLikeDeclaration getParent() { isNestedType(c, result) }
+
+  override ClassLikeDeclaration getDeclaringItem() { result = c }
+
+  override Identifier getNameNode() { none() }
+
+  override string toString() { result = "(parent:" + c.getName() + ")" }
+
+  override Location getLocation() { result = c.getLocation() }
+}
+
 /**
  * A type parameter of the special `UnknownType`.
  */
 
@@ -64,6 +64,13 @@ private module Input1 implements InputSig1<Location> {
         kind = 3 and
         tp0 = TUnknownTypeTypeParameter(id1) and
         id2 = 0
+        or
+        kind = 4 and
+        exists(ClassLikeDeclaration c |
+          tp0 = TParentTypeParameterType(c) and
+          id1 = idOfTypeParameterAstNode(c) and
+          id2 = 0
+        )
       |
         tp0 order by kind, id1, id2
       )
@@ -389,9 +396,6 @@ module Input3 implements InputSig3 {
     Unified::Callable getCallable() { result = c }
 
     override TypeMention getDeclaringType() {
-      result = c.(EnumConstructor).getEnum().getNameNode()
-      or
-      not c instanceof EnumConstructor and
       exists(ClassLikeDeclaration cls |
         c = cls.getAMember() and
         result = getClassLikeDeclarationTypeMention(cls)
@@ -405,9 +409,9 @@ module Input3 implements InputSig3 {
       or
       result = c.(FunctionDeclaration).getNameNode()
       or
-      result = c.(EnumConstructor).getEnclosingClass().getNameNode()
+      result = c.(EnumCaseConstructor).getEnumCaseClass().getNameNode()
       or
-      not c instanceof EnumConstructor and
+      not c instanceof EnumCaseConstructor and
       result = c.(ConstructorDeclaration).getNameNode()
     }
 
@@ -659,10 +663,20 @@ module Input3 implements InputSig3 {
       result = getQualifierTypeMention(invocation)
     }
 
-    private predicate constructionReceiver(Invocation i, Callable constructor, Expr receiver) {
-      constructor = i.getTargetImpl(_) and
-      constructor.asCallable() instanceof ConstructorDeclaration and
-      receiver = i.getArgument(0)
+    private predicate constructionReceiver(
+      Invocation i, Callable constructor, Expr receiver, TypePath enumPrefixPath
+    ) {
+      exists(ConstructorDeclaration cd |
+        constructor = i.getTargetImpl(_) and
+        cd = constructor.asCallable() and
+        receiver = i.getArgument(0)
+      |
+        enumPrefixPath =
+          TypePath::singleton(TParentTypeParameterType(cd.(EnumCaseConstructor).getEnumCaseClass()))
+        or
+        not cd instanceof EnumCaseConstructor and
+        enumPrefixPath.isEmpty()
+      )
     }
 
     /**
@@ -696,11 +710,15 @@ module Input3 implements InputSig3 {
       M3::ContextualTyping::ContextualReturnType<ContextualConstructorReturnTypeInput>;
 
     private predicate needsContextualTyping(Invocation i, TypePath path) {
-      exists(Callable constructor, Expr receiver, ClassLikeDeclarationType receiverType |
-        constructionReceiver(i, constructor, receiver) and
-        receiverType = inferType(receiver)
+      exists(
+        Callable constructor, Expr receiver, TypePath enumPrefixPath,
+        ClassLikeDeclarationType receiverType, TypePath path0
+      |
+        constructionReceiver(i, constructor, receiver, enumPrefixPath) and
+        receiverType = inferType(receiver) and
+        path = path0.stripPrefix(enumPrefixPath)
       |
-        ContextualConstructorReturnType::needsContextualTyping(i, path) and
+        ContextualConstructorReturnType::needsContextualTyping(i, path0) and
         receiverType = constructor.getDeclaringType().getType()
         or
         // inherited constructor
@@ -710,18 +728,18 @@ module Input3 implements InputSig3 {
         |
           declType = constructor.getDeclaringType().getType() and
           BaseTypes::rootTypesSatisfaction(receiverType, declType, abs, _, constraint) and
-          path = TypePath::singleton(tp)
+          path0 = TypePath::singleton(tp)
         |
           // `A<T> : B<T>`
-          exists(TypePath path0 |
-            BaseTypes::conditionSatisfiesConstraintTypeAt(abs, _, constraint, path0, tp) and
-            ContextualConstructorReturnType::needsContextualTyping(i, path0)
+          exists(TypePath path1 |
+            BaseTypes::conditionSatisfiesConstraintTypeAt(abs, _, constraint, path1, tp) and
+            ContextualConstructorReturnType::needsContextualTyping(i, path1)
           )
           or
           // `A<T> : B`
           tp = receiverType.getATypeParameter() and
           not BaseTypes::conditionSatisfiesConstraintTypeAt(abs, _, constraint, _, tp) and
-          not exists(Type t | t = i.getTypeQualifier(path) and not t instanceof PseudoType)
+          not exists(Type t | t = i.getTypeQualifier(path0) and not t instanceof PseudoType)
         )
       )
     }
@@ -734,8 +752,7 @@ module Input3 implements InputSig3 {
      * 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
+      constructionReceiver(n2, _, n1, prefix1) and
       prefix2.isEmpty()
     }
 
 
@@ -81,14 +81,6 @@ class TypeInferencePlugin extends Unit {
   /** Holds if `field` is a field of the tuple type `tuple` with the given `name`. */
   abstract predicate tupleField(Type tuple, string name, VariableDeclaration field);
 
-  /** Holds if `case` is an enum case constructor of `enum` with identifier `i`. */
-  abstract predicate isEnumConstructor(
-    ClassLikeDeclaration enum, ConstructorDeclaration case, Identifier i
-  );
-
-  /** Holds if `field` is an enum field of `enum`. */
-  abstract predicate isEnumField(ClassLikeDeclaration enum, VariableDeclaration field);
-
   /** Gets the inferred type for the given AST node and type path. */
   Type inferType(AstNode n, TypePath path) { none() }
 }
@@ -139,25 +131,6 @@ class TupleType extends Type {
   }
 }
 
-class EnumConstructor extends ConstructorDeclaration {
-  private ClassLikeDeclaration enum;
-  private Identifier id;
-
-  EnumConstructor() { any(TypeInferencePlugin p).isEnumConstructor(enum, this, id) }
-
-  ClassLikeDeclaration getEnum() { result = enum }
-
-  Identifier getNameNode() { result = id }
-}
-
-class EnumField extends VariableDeclaration {
-  private ClassLikeDeclaration enum;
-
-  EnumField() { any(TypeInferencePlugin p).isEnumField(enum, this) }
-
-  ClassLikeDeclaration getEnum() { result = enum }
-}
-
 Type inferType(AstNode n, TypePath path) { result = any(TypeInferencePlugin p).inferType(n, path) }
 
 Callable getFunctionInvoke(Type t) { result = any(TypeInferencePlugin p).getFunctionInvoke(t) }
 
@@ -108,17 +108,6 @@ private class EnumConstructor extends EnumCaseConstructor {
   Enum getEnum() { result = e }
 }
 
-private class EnumField extends VariableDeclaration {
-  private Enum e;
-
-  EnumField() {
-    this = e.getAMember() and
-    this.getAModifier().getValue() = "enum_case"
-  }
-
-  Enum getEnum() { result = e }
-}
-
 private predicate inferTypeAlias = inferType/2;
 
 private class SwiftTypeInferencePlugin extends Plugin::TypeInferencePlugin {
@@ -169,20 +158,6 @@ private class SwiftTypeInferencePlugin extends Plugin::TypeInferencePlugin {
     field = tuple.(TupleType).getField(name)
   }
 
-  override predicate isEnumConstructor(
-    ClassLikeDeclaration enum, ConstructorDeclaration case, Identifier i
-  ) {
-    case =
-      any(EnumConstructor ec |
-        enum = ec.getEnum() and
-        i = ec.getNameNode()
-      )
-  }
-
-  override predicate isEnumField(ClassLikeDeclaration enum, VariableDeclaration field) {
-    enum = field.(EnumField).getEnum()
-  }
-
   override Type inferType(AstNode n, TypePath path) {
     // todo: approximation for now
     n instanceof BinaryExpr and
 
@@ -63,18 +63,11 @@ private class NonAliasExprTypeMention extends ExprTypeMentionImpl {
 
   private Type getRootType0() {
     exists(Identifier i | i = getTypeFromRef(this) |
-      // for now, we resolve enum cases to their enclosing class
-      exists(EnumCaseClass c |
-        i = c.getNameNode() and
-        result.getNameNode() = c.getEnclosingClass().getNameNode()
-      )
-      or
-      not i = any(EnumCaseClass c).getNameNode() and
       result.getNameNode() = i and
       (
         not result instanceof AssociatedTypeParameterType
         or
-        result = TAssociatedTypeParameterType(this.getEnclosingClass(), _, _)
+        result = TAssociatedTypeParameterType(this.getEnclosingClass().resolve(), _, _)
       )
     )
     or
@@ -148,6 +141,55 @@ private class NonAliasExprTypeMention extends ExprTypeMentionImpl {
           path = TypePath::cons(tt.getPositionalTypeParameter(i), suffix)
         )
       )
+    or
+    this =
+      any(MemberAccessExpr mae |
+        exists(TypePath suffix |
+          result = mae.getBase().(TypeMention).getTypeAt(suffix) and
+          path =
+            TypePath::cons(TParentTypeParameterType(this.getRootType()
+                    .(ClassLikeDeclarationType)
+                    .getClassLikeDeclaration()), suffix)
+        )
+      )
+    or
+    exists(ClassLikeDeclarationType encl |
+      encl = this.getRootType() and
+      encl.getClassLikeDeclaration() = this.getEnclosingClass().resolve().getEnclosingClass*()
+    |
+      // A mention of a generic type without explicit type arguments and within
+      // the scope of the type, implicitly mentions all type parameters (including
+      // at the identifer that introduces the type):
+      //
+      // ```swift
+      // class Generic<T> {
+      //     let x: Generic // short-hand for `Generic<T>
+      // }
+      // ```
+      not this = any(GenericTypeExpr g).getBase() and
+      result = encl.getATypeParameter() and
+      not result instanceof ParentTypeParameterType and
+      path = TypePath::singleton(result)
+      or
+      // A mention of a nested type without an explicit qualifier and within the
+      // scope of the type, implicitly mentions the parent type (including
+      // at the identifer that introduces the type)
+      //
+      // ```swift
+      // class Outer {
+      //     class Inner {
+      //         let y: Inner // short-hand for `Outer.Inner`
+      //     }
+      // }
+      // ```
+      not this = any(MemberAccessExpr mae).getMemberNameNode() and
+      not this instanceof MemberAccessExpr and
+      exists(ParentTypeParameterType tp, TypePath suffix |
+        tp = TParentTypeParameterType(encl.getClassLikeDeclaration()) and
+        path = TypePath::cons(tp, suffix) and
+        result = tp.getParent().getNameNode().(TypeMention).getTypeAt(suffix)
+      )
+    )
   }
 }
 
@@ -172,25 +214,6 @@ private class GenericTypeExprTypeMention extends TypeMentionImpl, GenericTypeExp
   }
 }
 
-/** A class declaration mentions itself. */
-private class ClassLikeDeclarationTypeMention extends TypeMentionImpl, Identifier {
-  private ClassLikeDeclaration c;
-
-  ClassLikeDeclarationTypeMention() { this = c.getNameNode() }
-
-  ClassLikeDeclarationType getRootType() { c = result.getClassLikeDeclaration() }
-
-  ClassLikeDeclaration getClassLikeDeclaration() { result = c }
-
-  override Type getTypeAt(TypePath path) {
-    result = this.getRootType() and
-    path.isEmpty()
-    or
-    result = this.getRootType().getATypeParameter() and
-    path = TypePath::singleton(result)
-  }
-}
-
 TypeMention getClassLikeDeclarationTypeMention(ClassLikeDeclaration c) {
   result = c.getNameNode()
   or