Merge pull request #1866 from swiftwasm/main

pull[bot] · web-flow · commit e4ac96e8e9b7 · 2020-09-30T01:39:24.000Z
[pull] swiftwasm from main
diff --git a/include/swift/AST/Expr.h b/include/swift/AST/Expr.h
@@ -1332,6 +1332,7 @@ class SuperRefExpr : public Expr {
     : Expr(ExprKind::SuperRef, Implicit, SuperTy), Self(Self), Loc(Loc) {}
   
   VarDecl *getSelf() const { return Self; }
+  void setSelf(VarDecl *self) { Self = self; }
   
   SourceLoc getSuperLoc() const { return Loc; }
   SourceRange getSourceRange() const { return Loc; }
diff --git a/lib/AST/UnqualifiedLookup.cpp b/lib/AST/UnqualifiedLookup.cpp
@@ -144,9 +144,6 @@ namespace {
     static const unsigned targetLookup;
 #endif
 
-  public: // for exp debugging
-    unsigned resultsSizeBeforeLocalsPass = ~0;
-
   public:
     // clang-format off
     UnqualifiedLookupFactory(DeclNameRef Name,
@@ -708,16 +705,10 @@ void UnqualifiedLookupFactory::printScopes(raw_ostream &out) const {
 
 void UnqualifiedLookupFactory::printResults(raw_ostream &out) const {
   for (auto i : indices(Results)) {
-    if (i == resultsSizeBeforeLocalsPass)
-      out << "============== next pass ============\n";
     out << i << ": ";
     Results[i].print(out);
     out << "\n";
   }
-  if (resultsSizeBeforeLocalsPass == Results.size())
-    out << "============== next pass ============\n";
-  if (resultsSizeBeforeLocalsPass == ~0u)
-    out << "never tried locals\n\n";
 }
 
 void UnqualifiedLookupFactory::print(raw_ostream &OS) const {
diff --git a/lib/IDE/CodeCompletionCache.cpp b/lib/IDE/CodeCompletionCache.cpp
@@ -343,7 +343,7 @@ static void writeCachedModule(llvm::raw_ostream &out,
       if (R->getKind() == CodeCompletionResult::Declaration)
         LE.write(static_cast<uint8_t>(R->getAssociatedDeclKind()));
       else
-        LE.write(~static_cast<uint8_t>(0u));
+        LE.write(static_cast<uint8_t>(~0u));
       if (R->isOperator())
         LE.write(static_cast<uint8_t>(R->getOperatorKind()));
       else
diff --git a/lib/Parse/ParseExpr.cpp b/lib/Parse/ParseExpr.cpp
@@ -853,29 +853,6 @@ UnresolvedDeclRefExpr *Parser::parseExprOperator() {
   return new (Context) UnresolvedDeclRefExpr(name, refKind, DeclNameLoc(loc));
 }
 
-static VarDecl *getImplicitSelfDeclForSuperContext(Parser &P,
-                                                   DeclContext *DC,
-                                                   SourceLoc Loc) {
-  auto *methodContext = DC->getInnermostMethodContext();
-  if (!methodContext) {
-    P.diagnose(Loc, diag::super_not_in_class_method);
-    return nullptr;
-  }
-
-  // Do an actual lookup for 'self' in case it shows up in a capture list.
-  auto *methodSelf = methodContext->getImplicitSelfDecl();
-  auto *lookupSelf = P.lookupInScope(DeclNameRef(P.Context.Id_self));
-  if (lookupSelf && lookupSelf != methodSelf) {
-    // FIXME: This is the wrong diagnostic for if someone manually declares a
-    // variable named 'self' using backticks.
-    P.diagnose(Loc, diag::super_in_closure_with_capture);
-    P.diagnose(lookupSelf->getLoc(), diag::super_in_closure_with_capture_here);
-    return nullptr;
-  }
-
-  return methodSelf;
-}
-
 /// parseExprSuper
 ///
 ///   expr-super:
@@ -903,12 +880,8 @@ ParserResult<Expr> Parser::parseExprSuper() {
     return nullptr;
   }
 
-  VarDecl *selfDecl =
-      getImplicitSelfDeclForSuperContext(*this, CurDeclContext, superLoc);
-  if (!selfDecl)
-    return makeParserResult(new (Context) ErrorExpr(superLoc));
-
-  return makeParserResult(new (Context) SuperRefExpr(selfDecl, superLoc,
+  return makeParserResult(new (Context) SuperRefExpr(/*selfDecl=*/nullptr,
+                                                     superLoc,
                                                      /*Implicit=*/false));
 }
 
diff --git a/lib/Sema/LookupVisibleDecls.cpp b/lib/Sema/LookupVisibleDecls.cpp
@@ -693,11 +693,13 @@ static void lookupVisibleMemberDeclsImpl(
     }
   }
 
+  auto lookupTy = BaseTy;
+
   const auto synthesizeAndLookupTypeMembers = [&](NominalTypeDecl *NTD) {
     synthesizeMemberDeclsForLookup(NTD, CurrDC);
 
     // Look in for members of a nominal type.
-    lookupTypeMembers(BaseTy, BaseTy, Consumer, CurrDC, LS, Reason);
+    lookupTypeMembers(BaseTy, lookupTy, Consumer, CurrDC, LS, Reason);
   };
 
   llvm::SmallPtrSet<ClassDecl *, 8> Ancestors;
@@ -725,7 +727,7 @@ static void lookupVisibleMemberDeclsImpl(
     Ancestors.insert(CD);
 
     Reason = getReasonForSuper(Reason);
-    BaseTy = CD->getSuperclass();
+    lookupTy = CD->getSuperclass();
 
     LS = LS.withOnSuperclass();
     if (CD->inheritsSuperclassInitializers())
@@ -734,7 +736,7 @@ static void lookupVisibleMemberDeclsImpl(
 
   // Look into the inheritance chain.
   do {
-    const auto CurClass = BaseTy->getClassOrBoundGenericClass();
+    const auto CurClass = lookupTy->getClassOrBoundGenericClass();
 
     // FIXME: This path is no substitute for an actual circularity check.
     // The real fix is to check that the superclass doesn't introduce a
@@ -744,10 +746,10 @@ static void lookupVisibleMemberDeclsImpl(
 
     synthesizeAndLookupTypeMembers(CurClass);
 
-    BaseTy = CurClass->getSuperclass();
+    lookupTy = CurClass->getSuperclass();
     if (!CurClass->inheritsSuperclassInitializers())
       LS = LS.withoutInheritsSuperclassInitializers();
-  } while (BaseTy);
+  } while (lookupTy);
 }
 
 swift::DynamicLookupInfo::DynamicLookupInfo(
diff --git a/lib/Sema/MiscDiagnostics.cpp b/lib/Sema/MiscDiagnostics.cpp
@@ -2282,6 +2282,8 @@ bool swift::computeFixitsForOverridenDeclaration(
 namespace {
 
 class VarDeclUsageChecker : public ASTWalker {
+  DeclContext *DC;
+
   DiagnosticEngine &Diags;
   // Keep track of some information about a variable.
   enum {
@@ -2318,7 +2320,8 @@ class VarDeclUsageChecker : public ASTWalker {
   void operator=(const VarDeclUsageChecker &) = delete;
 
 public:
-  VarDeclUsageChecker(DiagnosticEngine &Diags) : Diags(Diags) {}
+  VarDeclUsageChecker(DeclContext *DC,
+                      DiagnosticEngine &Diags) : DC(DC), Diags(Diags) {}
 
   // After we have scanned the entire region, diagnose variables that could be
   // declared with a narrower usage kind.
@@ -3140,14 +3143,27 @@ std::pair<bool, Expr *> VarDeclUsageChecker::walkToExprPre(Expr *E) {
 void VarDeclUsageChecker::handleIfConfig(IfConfigDecl *ICD) {
   struct ConservativeDeclMarker : public ASTWalker {
     VarDeclUsageChecker &VDUC;
-    ConservativeDeclMarker(VarDeclUsageChecker &VDUC) : VDUC(VDUC) {}
+    SourceFile *SF;
+
+    ConservativeDeclMarker(VarDeclUsageChecker &VDUC)
+      : VDUC(VDUC), SF(VDUC.DC->getParentSourceFile()) {}
 
     Expr *walkToExprPost(Expr *E) override {
       // If we see a bound reference to a decl in an inactive #if block, then
       // conservatively mark it read and written.  This will silence "variable
       // unused" and "could be marked let" warnings for it.
       if (auto *DRE = dyn_cast<DeclRefExpr>(E))
         VDUC.addMark(DRE->getDecl(), RK_Read|RK_Written);
+      else if (auto *declRef = dyn_cast<UnresolvedDeclRefExpr>(E)) {
+        auto name = declRef->getName();
+        auto loc = declRef->getLoc();
+        if (name.isSimpleName() && loc.isValid()) {
+          auto *varDecl = dyn_cast_or_null<VarDecl>(
+            ASTScope::lookupSingleLocalDecl(SF, name.getFullName(), loc));
+          if (varDecl)
+            VDUC.addMark(varDecl, RK_Read|RK_Written);
+        }
+      }
       return E;
     }
   };
@@ -3166,7 +3182,7 @@ void VarDeclUsageChecker::handleIfConfig(IfConfigDecl *ICD) {
 void swift::
 performTopLevelDeclDiagnostics(TopLevelCodeDecl *TLCD) {
   auto &ctx = TLCD->getDeclContext()->getASTContext();
-  VarDeclUsageChecker checker(ctx.Diags);
+  VarDeclUsageChecker checker(TLCD, ctx.Diags);
   TLCD->walk(checker);
 }
 
@@ -3181,7 +3197,7 @@ void swift::performAbstractFuncDeclDiagnostics(AbstractFunctionDecl *AFD) {
   // be checked as part of their parent function or TopLevelCodeDecl.
   if (!AFD->getDeclContext()->isLocalContext()) {
     auto &ctx = AFD->getDeclContext()->getASTContext();
-    VarDeclUsageChecker checker(ctx.Diags);
+    VarDeclUsageChecker checker(AFD, ctx.Diags);
     AFD->walk(checker);
   }
 
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -3731,18 +3731,23 @@ enum class AbstractFunctionDeclLookupErrorKind {
   CandidateNotFunctionDeclaration
 };
 
-/// Returns the function declaration corresponding to the given base type
-/// (optional), function name, and lookup context.
+/// Returns the original function (in the context of a derivative or transpose
+/// function) declaration corresponding to the given base type (optional),
+/// function name, lookup context, and the expected original function type.
 ///
 /// If the base type of the function is specified, member lookup is performed.
 /// Otherwise, unqualified lookup is performed.
 ///
+/// If the expected original function type has a generic signature, any
+/// candidate with a less constrained type signature than the expected original
+/// function type will be treated as a viable candidate.
+///
 /// If the function declaration cannot be resolved, emits a diagnostic and
 /// returns nullptr.
 ///
 /// Used for resolving the referenced declaration in `@derivative` and
 /// `@transpose` attributes.
-static AbstractFunctionDecl *findAbstractFunctionDecl(
+static AbstractFunctionDecl *findAutoDiffOriginalFunctionDecl(
     DeclAttribute *attr, Type baseType, DeclNameRefWithLoc funcNameWithLoc,
     DeclContext *lookupContext, NameLookupOptions lookupOptions,
     const llvm::function_ref<Optional<AbstractFunctionDeclLookupErrorKind>(
@@ -4671,7 +4676,7 @@ static bool typeCheckDerivativeAttr(ASTContext &Ctx, Decl *D,
   }
 
   // Look up original function.
-  auto *originalAFD = findAbstractFunctionDecl(
+  auto *originalAFD = findAutoDiffOriginalFunctionDecl(
       attr, baseType, originalName, derivativeTypeCtx, lookupOptions,
       isValidOriginalCandidate, originalFnType);
   if (!originalAFD) {
@@ -5230,7 +5235,7 @@ void AttributeChecker::visitTransposeAttr(TransposeAttr *attr) {
   auto funcLoc = originalName.Loc.getBaseNameLoc();
   if (attr->getBaseTypeRepr())
     funcLoc = attr->getBaseTypeRepr()->getLoc();
-  auto *originalAFD = findAbstractFunctionDecl(
+  auto *originalAFD = findAutoDiffOriginalFunctionDecl(
       attr, baseType, originalName, transposeTypeCtx, lookupOptions,
       isValidOriginalCandidate, expectedOriginalFnType);
   if (!originalAFD) {
diff --git a/lib/Sema/TypeCheckCaptures.cpp b/lib/Sema/TypeCheckCaptures.cpp
@@ -572,8 +572,10 @@ class FindCapturedVars : public ASTWalker {
 
     // When we see a reference to the 'super' expression, capture 'self' decl.
     if (auto *superE = dyn_cast<SuperRefExpr>(E)) {
-      if (CurDC->isChildContextOf(superE->getSelf()->getDeclContext()))
-        addCapture(CapturedValue(superE->getSelf(), 0, superE->getLoc()));
+      if (auto *selfDecl = superE->getSelf()) {
+        if (CurDC->isChildContextOf(selfDecl->getDeclContext()))
+          addCapture(CapturedValue(selfDecl, 0, superE->getLoc()));
+      }
       return { false, superE };
     }
 
diff --git a/lib/Sema/TypeCheckConstraints.cpp b/lib/Sema/TypeCheckConstraints.cpp
@@ -1114,6 +1114,29 @@ namespace {
 
     bool shouldWalkCaptureInitializerExpressions() override { return true; }
 
+    VarDecl *getImplicitSelfDeclForSuperContext(SourceLoc Loc) {
+      auto *methodContext = DC->getInnermostMethodContext();
+      if (!methodContext) {
+        Ctx.Diags.diagnose(Loc, diag::super_not_in_class_method);
+        return nullptr;
+      }
+
+      // Do an actual lookup for 'self' in case it shows up in a capture list.
+      auto *methodSelf = methodContext->getImplicitSelfDecl();
+      auto *lookupSelf = ASTScope::lookupSingleLocalDecl(DC->getParentSourceFile(),
+                                                         Ctx.Id_self, Loc);
+      if (lookupSelf && lookupSelf != methodSelf) {
+        // FIXME: This is the wrong diagnostic for if someone manually declares a
+        // variable named 'self' using backticks.
+        Ctx.Diags.diagnose(Loc, diag::super_in_closure_with_capture);
+        Ctx.Diags.diagnose(lookupSelf->getLoc(),
+                           diag::super_in_closure_with_capture_here);
+        return nullptr;
+      }
+
+      return methodSelf;
+    }
+
     std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
       // If this is a call, record the argument expression.
       if (auto call = dyn_cast<ApplyExpr>(expr)) {
@@ -1156,6 +1179,17 @@ namespace {
         return std::make_pair(recursive, expr);
       };
 
+      // Resolve 'super' references.
+      if (auto *superRef = dyn_cast<SuperRefExpr>(expr)) {
+        auto loc = superRef->getLoc();
+        auto *selfDecl = getImplicitSelfDeclForSuperContext(loc);
+        if (selfDecl == nullptr)
+          return finish(true, new (Ctx) ErrorExpr(loc));
+
+        superRef->setSelf(selfDecl);
+        return finish(true, superRef);
+      }
+
       // For closures, type-check the patterns and result type as written,
       // but do not walk into the body. That will be type-checked after
       // we've determine the complete function type.
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
@@ -5799,6 +5799,9 @@ class SwiftToClangBasicReader :
 
 llvm::Expected<const clang::Type *>
 ModuleFile::getClangType(ClangTypeID TID) {
+  if (!getContext().LangOpts.UseClangFunctionTypes)
+    return nullptr;
+
   if (TID == 0)
     return nullptr;
 
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
@@ -4140,7 +4140,10 @@ class Serializer::TypeSerializer : public TypeVisitor<TypeSerializer> {
     using namespace decls_block;
 
     auto resultType = S.addTypeRef(fnTy->getResult());
-    auto clangType = S.addClangTypeRef(fnTy->getClangTypeInfo().getType());
+    auto clangType =
+      S.getASTContext().LangOpts.UseClangFunctionTypes
+      ? S.addClangTypeRef(fnTy->getClangTypeInfo().getType())
+      : ClangTypeID(0);
 
     unsigned abbrCode = S.DeclTypeAbbrCodes[FunctionTypeLayout::Code];
     FunctionTypeLayout::emitRecord(S.Out, S.ScratchRecord, abbrCode,
diff --git a/test/IDE/complete_sr13574.swift b/test/IDE/complete_sr13574.swift
@@ -0,0 +1,31 @@
+// RUN: %swift-ide-test -code-completion -source-filename %s -code-completion-token=OVERRIDE | %FileCheck %s --check-prefix=OVERRIDE
+// RUN: %swift-ide-test -code-completion -source-filename %s -code-completion-token=MEMBER | %FileCheck %s --check-prefix=MEMBER
+
+class Root {
+    func onRoot() {}
+}
+
+class Base<T: Hashable>: Root {
+    func onBase() -> T {}
+}
+
+class Derived<T: Hashable>: Base<T> {
+    func onDerived() {}
+
+    func #^OVERRIDE^#
+// OVERRIDE: Begin completions, 2 items
+// OVERRIDE-DAG: Decl[InstanceMethod]/Super/Erase[5]: override func onBase() -> T {|};
+// OVERRIDE-DAG: Decl[InstanceMethod]/Super/Erase[5]: override func onRoot() {|};
+// OVERRIDE-DAG: End completions
+
+}
+
+func testMember(val: Derived<Int>) {
+    val.#^MEMBER^#
+// MEMBER: Begin completions, 4 items
+// MEMBER-DAG: Keyword[self]/CurrNominal:          self[#Derived<Int>#]; name=self
+// MEMBER-DAG: Decl[InstanceMethod]/CurrNominal:   onDerived()[#Void#]; name=onDerived()
+// MEMBER-DAG: Decl[InstanceMethod]/Super:         onBase()[#Int#]; name=onBase()
+// MEMBER-DAG: Decl[InstanceMethod]/Super:         onRoot()[#Void#]; name=onRoot()
+// MEMBER: End completions
+}
diff --git a/test/LLVMPasses/merge_func_ptrauth.swift b/test/LLVMPasses/merge_func_ptrauth.swift
@@ -2,6 +2,7 @@
 
 // RUN: %empty-directory(%t) 
 // RUN: %target-build-swift -O -module-name=test %s -o %t/a.out
+// RUN: %target-codesign %t/a.out
 // RUN: %target-run %t/a.out | %FileCheck %s -check-prefix=CHECK-OUTPUT
 
 // REQUIRES: executable_test
diff --git a/test/Sema/clang_types_in_ast.swift b/test/Sema/clang_types_in_ast.swift
