Merge pull request #33717 from nathawes/merge-master-to-master-rebranch-2020-08-31

[master-rebranch] Merge in master resolving conflicts

Author: shahmishal

include/swift/AST/ASTContext.h

@@ -62,6 +62,7 @@ namespace swift {
   class BoundGenericType;
   class ClangModuleLoader;
   class ClangNode;
+  class ClangTypeConverter;
   class ConcreteDeclRef;
   class ConstructorDecl;
   class Decl;
@@ -586,6 +587,10 @@ class ASTContext final {
   Type getBridgedToObjC(const DeclContext *dc, Type type,
                         Type *bridgedValueType = nullptr) const;
 
+private:
+  ClangTypeConverter &getClangTypeConverter();
+
+public:
   /// Get the Clang type corresponding to a Swift function type.
   ///
   /// \param params The function parameters.
@@ -595,6 +600,14 @@ class ASTContext final {
   getClangFunctionType(ArrayRef<AnyFunctionType::Param> params, Type resultTy,
                        FunctionTypeRepresentation trueRep);
 
+  /// Get the canonical Clang type corresponding to a SIL function type.
+  ///
+  /// SIL analog of \c ASTContext::getClangFunctionType .
+  const clang::Type *
+  getCanonicalClangFunctionType(
+    ArrayRef<SILParameterInfo> params, Optional<SILResultInfo> result,
+    SILFunctionType::Representation trueRep);
+
   /// Get the Swift declaration that a Clang declaration was exported from,
   /// if applicable.
   const Decl *getSwiftDeclForExportedClangDecl(const clang::Decl *decl);

include/swift/AST/Decl.h

@@ -63,6 +63,7 @@ namespace swift {
   class Type;
   class Expr;
   class DeclRefExpr;
+  class ForeignAsyncConvention;
   class ForeignErrorConvention;
   class LiteralExpr;
   class BraceStmt;
@@ -6148,7 +6149,15 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// being dropped altogether. `None` is returned for a normal function
   /// or method.
   Optional<int> getForeignFunctionAsMethodSelfParameterIndex() const;
-  
+
+  /// Set information about the foreign async convention used by this
+  /// declaration.
+  void setForeignAsyncConvention(const ForeignAsyncConvention &convention);
+
+  /// Get information about the foreign async convention used by this
+  /// declaration, given that it is @objc and 'async'.
+  Optional<ForeignAsyncConvention> getForeignAsyncConvention() const;
+
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_AbstractFunctionDecl &&
            D->getKind() <= DeclKind::Last_AbstractFunctionDecl;
@@ -6277,7 +6286,8 @@ class FuncDecl : public AbstractFunctionDecl {
                                   DeclContext *Parent);
 
   static FuncDecl *createImported(ASTContext &Context, SourceLoc FuncLoc,
-                                  DeclName Name, SourceLoc NameLoc, bool Throws,
+                                  DeclName Name, SourceLoc NameLoc,
+                                  bool Async, bool Throws,
                                   ParameterList *BodyParams, Type FnRetType,
                                   DeclContext *Parent, ClangNode ClangN);
 

include/swift/AST/DiagnosticsCommon.def

@@ -188,5 +188,19 @@ ERROR(scanner_find_cycle, none,
 ERROR(scanner_arguments_invalid, none,
       "dependencies scanner cannot be configured with arguments: '%0'", (StringRef))
 
+//------------------------------------------------------------------------------
+// MARK: custom attribute diagnostics
+//------------------------------------------------------------------------------
+
+ERROR(ambiguous_custom_attribute_ref,none,
+      "ambiguous use of attribute %0", (Identifier))
+NOTE(ambiguous_custom_attribute_ref_fix,none,
+     "use '%0.' to reference the attribute %1 in module %2",
+     (StringRef, Identifier, Identifier))
+NOTE(found_attribute_candidate,none,
+     "found this attribute", ())
+ERROR(unknown_attribute,none,
+      "unknown attribute '%0'", (StringRef))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/DiagnosticsParse.def

@@ -1324,8 +1324,6 @@ ERROR(replace_equal_with_colon_for_value,none,
       "'=' has been replaced with ':' in attribute arguments", ())
 ERROR(expected_attribute_name,none,
       "expected an attribute name", ())
-ERROR(unknown_attribute,none,
-      "unknown attribute '%0'", (StringRef))
 ERROR(unexpected_lparen_in_attribute,none,
       "unexpected '(' in attribute '%0'", (StringRef))
 ERROR(duplicate_attribute,none,

include/swift/AST/DiagnosticsSema.def

@@ -2823,15 +2823,16 @@ WARNING(differentiable_nondiff_type_implicit_noderivative_fixit,none,
        /*nominalCanDeriveAdditiveArithmetic*/ bool))
 WARNING(differentiable_immutable_wrapper_implicit_noderivative_fixit,none,
       "synthesis of the 'Differentiable.move(along:)' requirement for %1 "
-      "requires 'wrappedValue' in property wrapper %0 to be mutable; "
-      "add an explicit '@noDerivative' attribute"
+      "requires 'wrappedValue' in property wrapper %0 to be mutable or have a "
+      "non-mutating 'move(along:)'; add an explicit '@noDerivative' attribute"
       "%select{|, or conform %1 to 'AdditiveArithmetic'}2",
       (/*wrapperType*/ Identifier, /*nominalName*/ Identifier,
        /*nominalCanDeriveAdditiveArithmetic*/ bool))
 WARNING(differentiable_let_property_implicit_noderivative_fixit,none,
       "synthesis of the 'Differentiable.move(along:)' requirement for %0 "
       "requires all stored properties not marked with `@noDerivative` to be "
-      "mutable; use 'var' instead, or add an explicit '@noDerivative' attribute"
+      "mutable or have a non-mutating 'move(along:)'; use 'var' instead, or "
+      "add an explicit '@noDerivative' attribute "
       "%select{|, or conform %0 to 'AdditiveArithmetic'}1",
       (/*nominalName*/ Identifier, /*nominalCanDeriveAdditiveArithmetic*/ bool))
 

include/swift/AST/ExtInfo.h

@@ -195,16 +195,8 @@ class ASTExtInfoBuilder {
 
   using Representation = FunctionTypeRepresentation;
 
-  static void assertIsFunctionType(const clang::Type *);
-
   ASTExtInfoBuilder(unsigned bits, ClangTypeInfo clangTypeInfo)
-      : bits(bits), clangTypeInfo(clangTypeInfo) {
-    // TODO: [clang-function-type-serialization] Once we start serializing
-    // the Clang type, we should also assert that the pointer is non-null.
-    auto Rep = Representation(bits & RepresentationMask);
-    if ((Rep == Representation::CFunctionPointer) && clangTypeInfo.type)
-      assertIsFunctionType(clangTypeInfo.type);
-  }
+      : bits(bits), clangTypeInfo(clangTypeInfo) {}
 
 public:
   // Constructor with all defaults.
@@ -255,10 +247,7 @@ class ASTExtInfoBuilder {
            DifferentiabilityKind::NonDifferentiable;
   }
 
-  /// Get the underlying ClangTypeInfo value if it is not the default value.
-  Optional<ClangTypeInfo> getClangTypeInfo() const {
-    return clangTypeInfo.empty() ? Optional<ClangTypeInfo>() : clangTypeInfo;
-  }
+  ClangTypeInfo getClangTypeInfo() const { return clangTypeInfo; }
 
   constexpr SILFunctionTypeRepresentation getSILRepresentation() const {
     unsigned rawRep = bits & RepresentationMask;
@@ -405,9 +394,7 @@ class ASTExtInfo {
 
   constexpr bool isDifferentiable() const { return builder.isDifferentiable(); }
 
-  Optional<ClangTypeInfo> getClangTypeInfo() const {
-    return builder.getClangTypeInfo();
-  }
+  ClangTypeInfo getClangTypeInfo() const { return builder.getClangTypeInfo(); }
 
   constexpr bool hasSelfParam() const { return builder.hasSelfParam(); }
 
@@ -519,20 +506,32 @@ class SILExtInfoBuilder {
   SILExtInfoBuilder(unsigned bits, ClangTypeInfo clangTypeInfo)
       : bits(bits), clangTypeInfo(clangTypeInfo) {}
 
+  static constexpr unsigned makeBits(Representation rep, bool isPseudogeneric,
+                                     bool isNoEscape, bool isAsync,
+                                     DifferentiabilityKind diffKind) {
+    return ((unsigned)rep) | (isPseudogeneric ? PseudogenericMask : 0) |
+           (isNoEscape ? NoEscapeMask : 0) | (isAsync ? AsyncMask : 0) |
+           (((unsigned)diffKind << DifferentiabilityMaskOffset) &
+            DifferentiabilityMask);
+  }
+
 public:
   // Constructor with all defaults.
-  SILExtInfoBuilder() : bits(0), clangTypeInfo(ClangTypeInfo(nullptr)) {}
+  SILExtInfoBuilder() : SILExtInfoBuilder(0, ClangTypeInfo(nullptr)) {}
 
   // Constructor for polymorphic type.
   SILExtInfoBuilder(Representation rep, bool isPseudogeneric, bool isNoEscape,
                     bool isAsync, DifferentiabilityKind diffKind,
                     const clang::Type *type)
-      : SILExtInfoBuilder(
-            ((unsigned)rep) | (isPseudogeneric ? PseudogenericMask : 0) |
-                (isNoEscape ? NoEscapeMask : 0) | (isAsync ? AsyncMask : 0) |
-                (((unsigned)diffKind << DifferentiabilityMaskOffset) &
-                 DifferentiabilityMask),
-            ClangTypeInfo(type)) {}
+      : SILExtInfoBuilder(makeBits(rep, isPseudogeneric, isNoEscape, isAsync,
+                                   diffKind),
+                          ClangTypeInfo(type)) {}
+
+  SILExtInfoBuilder(ASTExtInfoBuilder info, bool isPseudogeneric)
+      : SILExtInfoBuilder(makeBits(info.getSILRepresentation(), isPseudogeneric,
+                                   info.isNoEscape(), info.isAsync(),
+                                   info.getDifferentiabilityKind()),
+                          info.getClangTypeInfo()) {}
 
   void checkInvariants() const;
 
@@ -567,10 +566,8 @@ class SILExtInfoBuilder {
            DifferentiabilityKind::NonDifferentiable;
   }
 
-  /// Get the underlying ClangTypeInfo value if it is not the default value.
-  Optional<ClangTypeInfo> getClangTypeInfo() const {
-    return clangTypeInfo.empty() ? Optional<ClangTypeInfo>() : clangTypeInfo;
-  }
+  /// Get the underlying ClangTypeInfo value.
+  ClangTypeInfo getClangTypeInfo() const { return clangTypeInfo; }
 
   constexpr bool hasSelfParam() const {
     switch (getRepresentation()) {
@@ -698,9 +695,7 @@ class SILExtInfo {
 
   constexpr bool isDifferentiable() const { return builder.isDifferentiable(); }
 
-  Optional<ClangTypeInfo> getClangTypeInfo() const {
-    return builder.getClangTypeInfo();
-  }
+  ClangTypeInfo getClangTypeInfo() const { return builder.getClangTypeInfo(); }
 
   constexpr bool hasSelfParam() const { return builder.hasSelfParam(); }
 

include/swift/AST/ForeignAsyncConvention.h

@@ -0,0 +1,81 @@
+//===--- ForeignAsyncConvention.h - Async conventions -----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the ForeignAsyncConvention structure, which
+// describes the rules for how to detect that a foreign API is asynchronous.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_FOREIGN_ASYNC_CONVENTION_H
+#define SWIFT_FOREIGN_ASYNC_CONVENTION_H
+
+#include "swift/AST/Type.h"
+
+namespace swift {
+
+/// A small structure describing the async convention of a foreign declaration.
+class ForeignAsyncConvention {
+  /// The index of the completion handler parameters.
+  unsigned CompletionHandlerParamIndex;
+
+  /// When non-zero, indicates which parameter to the completion handler is the
+  /// Error? parameter (minus one) that makes this async function also throwing.
+  unsigned CompletionHandlerErrorParamIndex;
+public:
+  ForeignAsyncConvention()
+      : CompletionHandlerParamIndex(0), CompletionHandlerErrorParamIndex(0) { }
+
+  ForeignAsyncConvention(unsigned completionHandlerParamIndex,
+                         Optional<unsigned> completionHandlerErrorParamIndex)
+      : CompletionHandlerParamIndex(completionHandlerParamIndex),
+        CompletionHandlerErrorParamIndex(
+          completionHandlerErrorParamIndex
+            ? *completionHandlerErrorParamIndex + 1
+            : 0) {}
+
+  /// Retrieve the index of the completion handler parameter, which will be
+  /// erased from the Swift signature of the imported async function.
+  unsigned completionHandlerParamIndex() const {
+    return CompletionHandlerParamIndex;
+  }
+
+  /// Retrieve the index of the \c Error? parameter in the completion handler's
+  /// parameter list. When argument passed to this parameter is non-null, the
+  /// provided error will be thrown by the async function.
+  Optional<unsigned> completionHandlerErrorParamIndex() const {
+    if (CompletionHandlerErrorParamIndex == 0)
+      return None;
+
+    return CompletionHandlerErrorParamIndex - 1;
+  }
+
+  /// Whether the async function is throwing due to the completion handler
+  /// having an \c Error? parameter.
+  ///
+  /// Equivalent to \c static_cast<bool>(completionHandlerErrorParamIndex()).
+  bool isThrowing() const {
+    return CompletionHandlerErrorParamIndex != 0;
+  }
+
+  bool operator==(ForeignAsyncConvention other) const {
+    return CompletionHandlerParamIndex == other.CompletionHandlerParamIndex
+      && CompletionHandlerErrorParamIndex ==
+        other.CompletionHandlerErrorParamIndex;
+  }
+  bool operator!=(ForeignAsyncConvention other) const {
+    return !(*this == other);
+  }
+};
+
+}
+
+#endif

include/swift/AST/ForeignErrorConvention.h

@@ -81,6 +81,10 @@ class ForeignErrorConvention {
     }
 
     Info() = default;
+
+    Kind getKind() const {
+      return static_cast<Kind>(TheKind);
+    }
   };
 
 private:  
@@ -178,11 +182,24 @@ class ForeignErrorConvention {
   /// Returns the physical result type of the function, for functions
   /// that completely erase this information.
   CanType getResultType() const {
-    assert(getKind() == ZeroResult ||
-           getKind() == NonZeroResult);
+    assert(resultTypeErasedToVoid(getKind()));
     return ResultType;
   }
-  
+
+  /// Whether this kind of error import erases the result type to 'Void'.
+  static bool resultTypeErasedToVoid(Kind kind) {
+    switch (kind) {
+    case ZeroResult:
+    case NonZeroResult:
+      return true;
+
+    case ZeroPreservedResult:
+    case NilResult:
+    case NonNilError:
+      return false;
+    }
+  }
+
   bool operator==(ForeignErrorConvention other) const {
     return info.TheKind == other.info.TheKind
       && info.ErrorIsOwned == other.info.ErrorIsOwned

include/swift/AST/Types.h

@@ -2877,7 +2877,7 @@ class AnyFunctionType : public TypeBase {
                   unsigned NumParams, ExtInfo Info)
   : TypeBase(Kind, CanTypeContext, properties), Output(Output) {
     Bits.AnyFunctionType.ExtInfoBits = Info.getBits();
-    Bits.AnyFunctionType.HasClangTypeInfo = Info.getClangTypeInfo().hasValue();
+    Bits.AnyFunctionType.HasClangTypeInfo = !Info.getClangTypeInfo().empty();
     Bits.AnyFunctionType.NumParams = NumParams;
     assert(Bits.AnyFunctionType.NumParams == NumParams && "Params dropped!");
     // The use of both assert() and static_assert() is intentional.