[stdlib] [WIP] Eliminate version of Array.append(contentsOf:) that takes a Collection

CMakeLists.txt

@@ -13,7 +13,6 @@ set_property(GLOBAL PROPERTY JOB_POOL_LINK local_jobs)
 
 # First include general CMake utilities.
 include(SwiftUtils)
-include(CheckSymbolExists)
 
 #
 # User-configurable options that control the inclusion and default build
@@ -806,8 +805,6 @@ if(LIBXML2_FOUND)
   set(SWIFT_HAVE_LIBXML 1)
 endif()
 
-check_symbol_exists(el_wgets "histedit.h" HAVE_UNICODE_LIBEDIT)
-
 if (LLVM_ENABLE_DOXYGEN)
   message(STATUS "Doxygen: enabled")
 endif()

cmake/modules/AddSwift.cmake

@@ -341,8 +341,6 @@ function(_add_variant_link_flags)
     list(APPEND library_search_directories
         "${SWIFT_ANDROID_PREBUILT_PATH}/lib/gcc/arm-linux-androideabi/${SWIFT_ANDROID_NDK_GCC_VERSION}.x")
   else()
-    list(APPEND result "-lobjc")
-
     # If lto is enabled, we need to add the object path flag so that the LTO code
     # generator leaves the intermediate object file in a place where it will not
     # be touched. The reason why this must be done is that on OS X, debug info is
@@ -1588,7 +1586,7 @@ function(add_swift_library name)
         else()
           if("${sdk}" STREQUAL "WINDOWS")
             set(UNIVERSAL_LIBRARY_NAME
-              "${SWIFTLIB_DIR}/${SWIFT_SDK_${sdk}_LIB_SUBDIR}/lib${name}.lib")
+              "${SWIFTLIB_DIR}/${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${name}.lib")
           else()
             set(UNIVERSAL_LIBRARY_NAME
               "${SWIFTLIB_DIR}/${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${name}${CMAKE_STATIC_LIBRARY_SUFFIX}")

docs/ABI.rst

@@ -792,6 +792,9 @@ Globals
   global ::= type 'WV'                   // value witness table
   global ::= entity 'Wv' DIRECTNESS      // field offset
 
+  global ::= type 'Wy' // Outlined Copy Function Type
+  global ::= type 'We' // Outlined Consume Function Type
+
   DIRECTNESS ::= 'd'                         // direct
   DIRECTNESS ::= 'i'                         // indirect
 

docs/ARCOptimization.rst

@@ -886,7 +886,7 @@ Consider the following pseudo-Swift example::
 
   var GLOBAL_D : D = D1()
 
-  class C { deinit { GLOBAL_D = D2 } }
+  class C { deinit { GLOBAL_D = D2() } }
 
   func main() {
     let c = C()

include/swift/AST/ASTNode.h

@@ -18,6 +18,7 @@
 #define SWIFT_AST_AST_NODE_H
 
 #include "llvm/ADT/PointerUnion.h"
+#include "swift/AST/SourceEntityWalker.h"
 #include "swift/AST/TypeAlignments.h"
 
 namespace swift {
@@ -44,6 +45,9 @@ namespace swift {
     void walk(ASTWalker &Walker);
     void walk(ASTWalker &&walker) { walk(walker); }
 
+    void walk(SourceEntityWalker &Walker);
+    void walk(SourceEntityWalker &&walker) { walk(walker); }
+
     /// \brief get the underlying entity as a decl context if it is one,
     /// otherwise, return nullptr;
     DeclContext *getAsDeclContext() const;

include/swift/AST/Decl.h

@@ -5070,13 +5070,6 @@ class FuncDecl final : public AbstractFunctionDecl,
     FuncDeclBits.HasDynamicSelf = hasDynamicSelf;
   }
 
-  /// Determine whether this method has an archetype \c Self return
-  /// type. This is when a method defined in a protocol extension
-  /// returns Self. In this case, the type is not quite as constrained
-  /// as a dynamic Self, because it is bound to the conforming type,
-  /// not the dynamic type of the value.
-  bool hasArchetypeSelf() const;
-
   void getLocalCaptures(SmallVectorImpl<CapturedValue> &Result) const {
     return getCaptureInfo().getLocalCaptures(Result);
   }

include/swift/AST/DeclContext.h

@@ -390,11 +390,6 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   /// any of its parents have generic parameters.
   bool isGenericContext() const;
 
-  /// Determine whether this declaration context is a generic context that has
-  /// been fully type checked, meaning it has a valid GenericSignature and
-  /// GenericEnvironment.
-  bool isValidGenericContext() const;
-
   /// Determine whether the innermost context is generic.
   bool isInnermostContextGeneric() const;
 

include/swift/AST/DiagnosticsSema.def

@@ -2432,6 +2432,9 @@ NOTE(fix_unqualified_access_top_level_multi,none,
      "use '%0' to reference the %1 in module %2",
      (StringRef, DescriptiveDeclKind, Identifier))
 
+ERROR(unsupported_special_decl_ref, none,
+      "referencing %0 as a function value is not implemented", (Identifier))
+
 WARNING(use_of_qq_on_non_optional_value,none,
         "left side of nil coalescing operator '?""?' has non-optional type %0, "
         "so the right side is never used", (Type))

include/swift/AST/Expr.h

@@ -2522,6 +2522,69 @@ class ForceValueExpr : public Expr {
   }
 };
 
+/// \brief An expression that grants temporary escapability to a nonescaping
+/// closure value.
+///
+/// This expression is formed by the type checker when a call to the
+/// `withoutActuallyEscaping` declaration is made.
+class MakeTemporarilyEscapableExpr : public Expr {
+  Expr *NonescapingClosureValue;
+  OpaqueValueExpr *EscapingClosureValue;
+  Expr *SubExpr;
+  SourceLoc NameLoc, LParenLoc, RParenLoc;
+
+public:
+  MakeTemporarilyEscapableExpr(SourceLoc NameLoc,
+                               SourceLoc LParenLoc,
+                               Expr *NonescapingClosureValue,
+                               Expr *SubExpr,
+                               SourceLoc RParenLoc,
+                               OpaqueValueExpr *OpaqueValueForEscapingClosure,
+                               bool implicit = false)
+    : Expr(ExprKind::MakeTemporarilyEscapable, implicit, Type()),
+      NonescapingClosureValue(NonescapingClosureValue),
+      EscapingClosureValue(OpaqueValueForEscapingClosure),
+      SubExpr(SubExpr),
+      NameLoc(NameLoc), LParenLoc(LParenLoc), RParenLoc(RParenLoc)
+  {}
+
+  SourceLoc getStartLoc() const {
+    return NameLoc;
+  }
+  SourceLoc getEndLoc() const {
+    return RParenLoc;
+  }
+
+  SourceLoc getLoc() const {
+    return NameLoc;
+  }
+
+  /// Retrieve the opaque value representing the escapable copy of the
+  /// closure.
+  OpaqueValueExpr *getOpaqueValue() const { return EscapingClosureValue; }
+
+  /// Retrieve the nonescaping closure expression.
+  Expr *getNonescapingClosureValue() const {
+    return NonescapingClosureValue;
+  }
+  void setNonescapingClosureValue(Expr *e) {
+    NonescapingClosureValue = e;
+  }
+
+  /// Retrieve the subexpression that has access to the escapable copy of the
+  /// closure.
+  Expr *getSubExpr() const {
+    return SubExpr;
+  }
+  void setSubExpr(Expr *e) {
+    SubExpr = e;
+  }
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::MakeTemporarilyEscapable;
+  }
+};
+
 /// \brief An expression that opens up a value of protocol or protocol
 /// composition type and gives a name to its dynamic type.
 ///

include/swift/AST/ExprNodes.def

@@ -107,6 +107,7 @@ EXPR(BindOptional, Expr)
 EXPR(OptionalEvaluation, Expr)
 EXPR(ForceValue, Expr)
 EXPR(OpenExistential, Expr)
+EXPR(MakeTemporarilyEscapable, Expr)
 ABSTRACT_EXPR(Apply, Expr)
   EXPR(Call, ApplyExpr)
   EXPR(PrefixUnary, ApplyExpr)

include/swift/AST/Pattern.h

@@ -535,7 +535,10 @@ class EnumElementPattern : public Pattern {
                                     : NameLoc;
   }
   SourceLoc getEndLoc() const {
-    return SubPattern ? SubPattern->getSourceRange().End : NameLoc;
+    if (SubPattern && SubPattern->getSourceRange().isValid()) {
+      return SubPattern->getSourceRange().End;
+    }
+    return NameLoc;
   }
   SourceRange getSourceRange() const { return {getStartLoc(), getEndLoc()}; }
 

include/swift/AST/SourceEntityWalker.h

@@ -53,6 +53,12 @@ class SourceEntityWalker {
   /// Walks the provided DeclContext.
   /// \returns true if traversal was aborted, false otherwise.
   bool walk(DeclContext *DC);
+  /// Walks the provided Stmt.
+  /// \returns true if traversal was aborted, false otherwise.
+  bool walk(Stmt *S);
+  /// Walks the provided Expr.
+  /// \returns true if traversal was aborted, false otherwise.
+  bool walk(Expr *E);
 
   /// This method is called when first visiting a decl, before walking into its
   /// children.  If it returns false, the subtree is skipped.

include/swift/AST/Type.h

@@ -280,9 +280,6 @@ class Type {
   /// Return the name of the type as a string, for use in diagnostics only.
   std::string getString(const PrintOptions &PO = PrintOptions()) const;
 
-  /// Get the canonical type, or return null if the type is null.
-  CanType getCanonicalTypeOrNull() const; // in Types.h
-
   /// Computes the join between two types.
   ///
   /// The join of two types is the most specific type that is a supertype of

include/swift/AST/TypeNodes.def

@@ -107,7 +107,7 @@ ABSTRACT_TYPE(Nominal, Type)
   TYPE(Enum, NominalType)
   TYPE(Struct, NominalType)
   TYPE(Class, NominalType)
-  ALWAYS_CANONICAL_TYPE(Protocol, NominalType)
+  TYPE(Protocol, NominalType)
   TYPE_RANGE(Nominal, Enum, Protocol)
 ABSTRACT_TYPE(AnyMetatype, Type)
   TYPE(Metatype, AnyMetatypeType)

include/swift/AST/TypeRepr.h

@@ -309,6 +309,10 @@ class GenericIdentTypeRepr : public ComponentIdentTypeRepr {
     : ComponentIdentTypeRepr(TypeReprKind::GenericIdent, Loc, Id),
       GenericArgs(GenericArgs), AngleBrackets(AngleBrackets) {
     assert(!GenericArgs.empty());
+#ifndef NDEBUG
+    for (auto arg : GenericArgs)
+      assert(arg != nullptr);
+#endif
   }
 
   ArrayRef<TypeRepr*> getGenericArgs() const { return GenericArgs; }

include/swift/AST/Types.h

@@ -64,6 +64,7 @@ namespace swift {
   class TypeVariableType;
   class ValueDecl;
   class ModuleDecl;
+  class ModuleType;
   class ProtocolConformance;
   struct SILArgumentConvention;
   enum OptionalTypeKind : unsigned;
@@ -489,7 +490,11 @@ class alignas(1 << TypeAlignInBits) TypeBase {
 
   /// Erase the given opened existential type by replacing it with its
   /// existential type throughout the given type.
-  Type eraseOpenedExistential(ModuleDecl *module, ArchetypeType *opened);
+  Type eraseOpenedExistential(ArchetypeType *opened);
+
+  /// Erase DynamicSelfType from the given type by replacing it with its
+  /// underlying type.
+  Type eraseDynamicSelfType();
 
   /// \brief Compute and return the set of type variables that occur within this
   /// type.
@@ -643,6 +648,23 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// with a class type.
   bool mayHaveSuperclass();
 
+  /// \brief Determine whether this type can be used as a base type for AST
+  /// name lookup, which is the case for nominal types, protocol compositions
+  /// and archetypes.
+  ///
+  /// Generally, the static vs instanec and mutating vs nonmutating distinction
+  /// is handled elsewhere, so metatypes, lvalue types and inout types are not
+  /// allowed here.
+  ///
+  /// Similarly, tuples formally have members, but this does not go through
+  /// name lookup.
+  bool mayHaveMembers() {
+    return (is<ArchetypeType>() ||
+            is<ModuleType>() ||
+            isExistentialType() ||
+            getAnyNominal());
+  }
+
   /// \brief Retrieve the superclass of this type.
   ///
   /// \param resolver The resolver for lazy type checking, or null if the
@@ -778,6 +800,13 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// the result would be the (parenthesized) type ((int, int)).
   Type getUnlabeledType(ASTContext &Context);
 
+  /// Retrieve the type without any labels around it. For example, given
+  /// \code
+  /// (p : int)
+  /// \endcode
+  /// the result would be the (unparenthesized) type 'int'.
+  Type getWithoutImmediateLabel();
+
   /// Retrieve the type without any parentheses around it.
   Type getWithoutParens();
 
@@ -792,8 +821,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// replacing the type. With uncurry level == 0, this simply
   /// replaces the current type with the new result type.
   Type replaceCovariantResultType(Type newResultType,
-                                  unsigned uncurryLevel,
-                                  bool preserveOptionality = true);
+                                  unsigned uncurryLevel);
 
   /// Returns a new function type exactly like this one but with the self
   /// parameter replaced. Only makes sense for function members of types.
@@ -3548,7 +3576,7 @@ class ProtocolType : public NominalType, public llvm::FoldingSetNode {
 public:
   /// \brief Retrieve the type when we're referencing the given protocol.
   /// declaration.
-  static ProtocolType *get(ProtocolDecl *D, const ASTContext &C);
+  static ProtocolType *get(ProtocolDecl *D, Type Parent, const ASTContext &C);
 
   ProtocolDecl *getDecl() const {
     return reinterpret_cast<ProtocolDecl *>(NominalType::getDecl());
@@ -3593,7 +3621,8 @@ class ProtocolType : public NominalType, public llvm::FoldingSetNode {
 
 private:
   friend class NominalTypeDecl;
-  ProtocolType(ProtocolDecl *TheDecl, const ASTContext &Ctx);
+  ProtocolType(ProtocolDecl *TheDecl, Type Parent, const ASTContext &Ctx,
+               RecursiveTypeProperties properties);
 };
 BEGIN_CAN_TYPE_WRAPPER(ProtocolType, NominalType)
   void getAnyExistentialTypeProtocols(SmallVectorImpl<ProtocolDecl *> &protos) {
@@ -4431,12 +4460,7 @@ inline Type TypeBase::getRValueObjectType() {
     type = lv->getObjectType();
 
   // Look through argument list tuples.
-  if (auto tupleTy = type->getAs<TupleType>()) {
-    if (tupleTy->getNumElements() == 1 && !tupleTy->getElement(0).isVararg())
-      type = tupleTy->getElementType(0);
-  }
-
-  return type;
+  return type->getWithoutImmediateLabel();
 }
 
 /// getLValueOrInOutObjectType - For an @lvalue or inout type, retrieves the
@@ -4526,10 +4550,6 @@ ParameterTypeFlags::fromParameterType(Type paramTy, bool isVariadic) {
   return {isVariadic, autoclosure, escaping};
 }
 
-inline CanType Type::getCanonicalTypeOrNull() const {
-  return isNull() ? CanType() : getPointer()->getCanonicalType();
-}
-
 #define TYPE(id, parent)
 #define SUGARED_TYPE(id, parent) \
 template <> \

include/swift/Basic/DemangleNodes.def

@@ -177,5 +177,7 @@ NODE(ThrowsAnnotation)
 NODE(EmptyList)
 NODE(FirstElementMarker)
 NODE(VariadicMarker)
+NODE(OutlinedCopy)
+NODE(OutlinedConsume)
 #undef CONTEXT_NODE
 #undef NODE