Make Self available to member functions (SE-0068?)

lib/Sema/TypeCheckConstraints.cpp

@@ -551,6 +551,25 @@ resolveDeclRefExpr(UnresolvedDeclRefExpr *UDRE, DeclContext *DC) {
     };
 
     if (!isConfused) {
+      if (Name == Context.Id_Self) {
+//        return new (Context) TypeExpr(TypeLoc::withoutLoc(
+//            DynamicSelfType::get(
+//              DC->getInnermostTypeContext()
+//                                 ->getSelfTypeInContext()
+//                                 //->getDeclaredInterfaceType()
+//                                 , Context)));
+        auto selfs = lookupUnqualified(DC, Context.Id_self, Loc, lookupOptions);
+        if (!selfs.empty()) {
+          ValueDecl *D = selfs.front().getValueDecl();
+          Expr *E = new (Context) DeclRefExpr(D, nameLoc, /*Implicit=*/false);
+          if (auto func = dyn_cast<AbstractFunctionDecl>(
+                                        DC->getInnermostMethodContext()))
+            if (func->isStatic())
+              return E;
+          return new (Context) DynamicTypeExpr(Loc, Loc, E, Loc, Type());
+        }
+      }
+
       TypoCorrectionResults corrections(*this, Name, nameLoc);
       performTypoCorrection(DC, UDRE->getRefKind(), Type(),
                             lookupOptions, corrections);

lib/Sema/TypeCheckType.cpp

@@ -1061,6 +1061,8 @@ static Type diagnoseUnknownType(TypeResolution resolution,
         // type. Fix this by replacing 'Self' with the nominal type name.
         assert(!isa<ProtocolDecl>(nominal) && "Cannot be a protocol");
 
+        return nominal->getDeclaredInterfaceType();
+
         // Produce a Fix-It replacing 'Self' with the nominal type name.
         auto name = getDeclNameFromContext(dc, nominal);
         diags.diagnose(comp->getIdLoc(), diag::self_in_nominal, name)

test/decl/func/dynamic_self.swift

@@ -89,7 +89,7 @@ class C1 {
 
     if b { return self.init(int: 5) }
 
-    return Self() // expected-error{{use of unresolved identifier 'Self'; did you mean 'self'?}}
+    return Self() // expected-error{{non-nominal type 'Self.Type' does not support explicit initialization}}
   }
 
   // This used to crash because metatype construction went down a
@@ -412,4 +412,46 @@ class SelfOperator {
 func useSelfOperator() {
   let s = SelfOperator()
   _ = s + s
-}
+}
+
+// These references to Self are now possible
+
+class A<T> {
+  let b: Int
+  required init(a: Int) {
+    print("\(Self).\(#function)")
+    b = a
+  }
+  static func z() {
+    print("\(Self.self).\(#function)")
+  }
+  class func y() {
+    print("\(Self).\(#function)")
+  }
+  func x() {
+    print("\(Self.self).\(#function)")
+    Self.y()
+    Self.z()
+    _ = Self.init(a: 77)
+  }
+}
+
+class B: A<Int> {
+  let a: Int
+  required convenience init(a: Int) {
+    print("\(Self).\(#function)")
+    self.init()
+  }
+  init() {
+    print("\(Self.self).\(#function)")
+    Self.y()
+    Self.z()
+    a = 99
+    super.init(a: 88)
+  }
+  override class func y() {
+    print("\(Self).\(#function)")
+  }
+}
+
+B().x()