[pull] swiftwasm from master

cmake/modules/AddSwift.cmake

@@ -555,6 +555,15 @@ function(add_swift_host_library name)
       target_link_options(${name} PRIVATE
         "LINKER:-current_version,${SWIFT_COMPILER_VERSION}")
     endif()
+
+    set(DEPLOYMENT_VERSION "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_DEPLOYMENT_VERSION}")
+    # MSVC, clang-cl, gcc don't understand -target.
+    if(CMAKE_C_COMPILER_ID MATCHES "Clang" AND NOT SWIFT_COMPILER_IS_MSVC_LIKE)
+      get_target_triple(target target_variant "${SWIFT_HOST_VARIANT_SDK}" "${SWIFT_HOST_VARIANT_ARCH}"
+        MACCATALYST_BUILD_FLAVOR ""
+        DEPLOYMENT_VERSION "${DEPLOYMENT_VERSION}")
+      target_link_options(${name} PRIVATE -target;${target})
+    endif()
   endif()
 
   add_dependencies(dev ${name})

docs/Testing.md

@@ -24,6 +24,24 @@ We use multiple approaches to test the Swift toolchain.
   locally before committing.  (Usually on a single platform, and not necessarily
   all tests.)
 * Buildbots run all tests, on all supported platforms.
+  [Smoke testing](ContinuousIntegration.md#smoke-testing)
+  skips the iOS, tvOS, and watchOS platforms.
+
+The [test/lit.cfg](https://github.com/apple/swift/blob/master/test/lit.cfg)
+uses an iOS 10.3 simulator configuration named "iPhone 5" for 32-bit testing.
+
+1.  Download and install the iOS 10.3 simulator runtime, in Xcode's
+    [Components](https://help.apple.com/xcode/#/deva7379ae35) preferences.
+
+2.  Create an "iPhone 5" simulator configuration, either in Xcode's
+    [Devices and Simulators](https://help.apple.com/xcode/#/devf225e58da)
+    window, or with the command line:
+
+    ```sh
+    xcrun simctl create 'iPhone 5' 'com.apple.CoreSimulator.SimDeviceType.iPhone-5'
+    ```
+
+3.  Append `--ios` to the `utils/build-script` command line (see below).
 
 ### Testsuite subsets
 

include/swift/ABI/TypeIdentity.h

@@ -184,7 +184,7 @@ class ParsedTypeIdentity {
   StringRef FullIdentity;
 
   /// Any extended information that type might have.
-  Optional<TypeImportInfo<StringRef>> ImportInfo;
+  llvm::Optional<TypeImportInfo<StringRef>> ImportInfo;
 
   /// The ABI name of the type.
   StringRef getABIName() const {

include/swift/AST/DeclContext.h

@@ -51,6 +51,7 @@ namespace swift {
   class Expr;
   class GenericParamList;
   class LazyMemberLoader;
+  class GenericContext;
   class GenericSignature;
   class GenericTypeParamDecl;
   class GenericTypeParamType;
@@ -566,41 +567,6 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   LLVM_READONLY
   ASTContext &getASTContext() const;
 
-  /// Retrieve the set of protocols whose conformances will be
-  /// associated with this declaration context.
-  ///
-  /// This function differs from \c getLocalConformances() in that it
-  /// returns protocol declarations, not protocol conformances, and
-  /// therefore does not require the protocol conformances to be
-  /// formed.
-  ///
-  /// \param lookupKind The kind of lookup to perform.
-  ///
-  /// FIXME: This likely makes more sense on IterableDeclContext or
-  /// something similar.
-  SmallVector<ProtocolDecl *, 2>
-  getLocalProtocols(ConformanceLookupKind lookupKind
-                      = ConformanceLookupKind::All) const;
-
-  /// Retrieve the set of protocol conformances associated with this
-  /// declaration context.
-  ///
-  /// \param lookupKind The kind of lookup to perform.
-  ///
-  /// FIXME: This likely makes more sense on IterableDeclContext or
-  /// something similar.
-  SmallVector<ProtocolConformance *, 2>
-  getLocalConformances(ConformanceLookupKind lookupKind
-                         = ConformanceLookupKind::All) const;
-
-  /// Retrieve diagnostics discovered while expanding conformances for this
-  /// declaration context. This operation then removes those diagnostics from
-  /// consideration, so subsequent calls to this function with the same
-  /// declaration context that have not had any new extensions bound
-  /// will see an empty array.
-  SmallVector<ConformanceDiagnostic, 4>
-  takeConformanceDiagnostics() const;
-
   /// Retrieves a list of separately imported overlays which are shadowing
   /// \p declaring. If any \p overlays are returned, qualified lookups into
   /// \p declaring should be performed into \p overlays instead; since they
@@ -815,9 +781,40 @@ class IterableDeclContext {
   /// valid).
   bool wasDeserialized() const;
 
+  /// Retrieve the set of protocols whose conformances will be
+  /// associated with this declaration context.
+  ///
+  /// This function differs from \c getLocalConformances() in that it
+  /// returns protocol declarations, not protocol conformances, and
+  /// therefore does not require the protocol conformances to be
+  /// formed.
+  ///
+  /// \param lookupKind The kind of lookup to perform.
+  SmallVector<ProtocolDecl *, 2>
+  getLocalProtocols(ConformanceLookupKind lookupKind
+                      = ConformanceLookupKind::All) const;
+
+  /// Retrieve the set of protocol conformances associated with this
+  /// declaration context.
+  ///
+  /// \param lookupKind The kind of lookup to perform.
+  SmallVector<ProtocolConformance *, 2>
+  getLocalConformances(ConformanceLookupKind lookupKind
+                         = ConformanceLookupKind::All) const;
+
+  /// Retrieve diagnostics discovered while expanding conformances for this
+  /// declaration context. This operation then removes those diagnostics from
+  /// consideration, so subsequent calls to this function with the same
+  /// declaration context that have not had any new extensions bound
+  /// will see an empty array.
+  SmallVector<ConformanceDiagnostic, 4> takeConformanceDiagnostics() const;
+
   /// Return 'this' as a \c Decl.
   const Decl *getDecl() const;
 
+  /// Return 'this' as a \c GenericContext.
+  const GenericContext *getAsGenericContext() const;
+
   /// Get the DeclID this Decl was deserialized from.
   serialization::DeclID getDeclID() const {
     assert(wasDeserialized());

include/swift/AST/Expr.h

@@ -4227,9 +4227,7 @@ class DefaultArgumentExpr final : public Expr {
       DefaultArgsOwner(defaultArgsOwner), ParamIndex(paramIndex), Loc(loc),
       ContextOrCallerSideExpr(dc) { }
 
-  SourceRange getSourceRange() const { return {}; }
-
-  SourceLoc getArgumentListLoc() const { return Loc; }
+  SourceRange getSourceRange() const { return Loc; }
 
   ConcreteDeclRef getDefaultArgsOwner() const {
     return DefaultArgsOwner;

include/swift/AST/TypeCheckRequests.h

@@ -2259,7 +2259,8 @@ void simple_display(llvm::raw_ostream &out, ConformanceLookupKind kind);
 /// must also be reported so it can be checked as well.
 class LookupAllConformancesInContextRequest
     : public SimpleRequest<LookupAllConformancesInContextRequest,
-                           ProtocolConformanceLookupResult(const DeclContext *),
+                           ProtocolConformanceLookupResult(
+                               const IterableDeclContext *),
                            RequestFlags::Uncached |
                                RequestFlags::DependencySink |
                                RequestFlags::DependencySource> {
@@ -2271,7 +2272,7 @@ class LookupAllConformancesInContextRequest
 
   // Evaluation.
   ProtocolConformanceLookupResult
-  evaluate(Evaluator &evaluator, const DeclContext *DC) const;
+  evaluate(Evaluator &evaluator, const IterableDeclContext *IDC) const;
 
 public:
   // Incremental dependencies
@@ -2429,6 +2430,32 @@ class ResolveTypeRequest
 void simple_display(llvm::raw_ostream &out, const TypeResolution *resolution);
 SourceLoc extractNearestSourceLoc(const TypeRepr *repr);
 
+/// Checks to see if any of the imports in a module use `@_implementationOnly`
+/// in one file and not in another.
+///
+/// Like redeclaration checking, but for imports.
+///
+/// This is a request purely to ensure that we don't need to perform the same
+/// checking for each file we resolve imports for.
+/// FIXME: Once import resolution operates at module-level, this checking can
+/// integrated into it.
+class CheckInconsistentImplementationOnlyImportsRequest
+    : public SimpleRequest<CheckInconsistentImplementationOnlyImportsRequest,
+                           evaluator::SideEffect(ModuleDecl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  evaluator::SideEffect evaluate(Evaluator &evaluator, ModuleDecl *mod) const;
+
+public:
+  // Cached.
+  bool isCached() const { return true; }
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -29,6 +29,8 @@ SWIFT_REQUEST(TypeChecker, AttachedPropertyWrappersRequest,
               NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, CallerSideDefaultArgExprRequest,
               Expr *(DefaultArgumentExpr *), SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, CheckInconsistentImplementationOnlyImportsRequest,
+              evaluator::SideEffect(ModuleDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, CheckRedeclarationRequest,
               evaluator::SideEffect(ValueDecl *),
               Uncached, NoLocationInfo)
@@ -256,7 +258,7 @@ SWIFT_REQUEST(TypeChecker, ScopedImportLookupRequest,
 SWIFT_REQUEST(TypeChecker, ClosureHasExplicitResultRequest,
               bool(ClosureExpr *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, LookupAllConformancesInContextRequest,
-              ProtocolConformanceLookupResult(const DeclContext *),
+              ProtocolConformanceLookupResult(const IterableDeclContext *),
               Uncached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SimpleDidSetRequest, 
               bool(AccessorDecl *), Cached, NoLocationInfo)

include/swift/Basic/LLVM.h

@@ -45,7 +45,9 @@ namespace llvm {
   template<typename T> class MutableArrayRef;
 #endif
   template<typename T> class TinyPtrVector;
+#if !defined(swiftCore_EXPORTS)
   template<typename T> class Optional;
+#endif
   template <typename ...PTs> class PointerUnion;
   template <typename IteratorT> class iterator_range;
   class SmallBitVector;
@@ -75,7 +77,9 @@ namespace swift {
 #endif
   using llvm::iterator_range;
   using llvm::None;
+#if !defined(swiftCore_EXPORTS)
   using llvm::Optional;
+#endif
   using llvm::PointerUnion;
   using llvm::SmallBitVector;
   using llvm::SmallPtrSet;

include/swift/Basic/LangOptions.h

@@ -484,11 +484,7 @@ namespace swift {
     /// 4.2 GHz Intel Core i7.
     /// (It's arbitrary, but will keep the compiler from taking too much time.)
     unsigned SwitchCheckingInvocationThreshold = 200000;
-
-    /// Whether to delay checking that benefits from having the entire
-    /// module parsed, e.g., Objective-C method override checking.
-    bool DelayWholeModuleChecking = false;
-
+
     /// If true, the time it takes to type-check each function will be dumped
     /// to llvm::errs().
     bool DebugTimeFunctionBodies = false;
@@ -497,11 +493,6 @@ namespace swift {
     /// dumped to llvm::errs().
     bool DebugTimeExpressions = false;
 
-    /// Indicate that the type checker is checking code that will be
-    /// immediately executed. This will suppress certain warnings
-    /// when executing scripts.
-    bool InImmediateMode = false;
-
     /// Indicate that the type checker should skip type-checking non-inlinable
     /// function bodies.
     bool SkipNonInlinableFunctionBodies = false;

include/swift/Basic/STLExtras.h

@@ -528,19 +528,18 @@ makeOptionalTransformRange(Range range, OptionalTransform op) {
 /// the result in an optional to indicate success or failure.
 template<typename Subclass>
 struct DowncastAsOptional {
-  template<typename Superclass>
+  template <typename Superclass>
   auto operator()(Superclass &value) const
-         -> Optional<decltype(llvm::cast<Subclass>(value))> {
+      -> llvm::Optional<decltype(llvm::cast<Subclass>(value))> {
     if (auto result = llvm::dyn_cast<Subclass>(value))
       return result;
 
     return None;
   }
 
-  template<typename Superclass>
+  template <typename Superclass>
   auto operator()(const Superclass &value) const
-         -> Optional<decltype(llvm::cast<Subclass>(value))>
-  {
+      -> llvm::Optional<decltype(llvm::cast<Subclass>(value))> {
     if (auto result = llvm::dyn_cast<Subclass>(value))
       return result;
 

include/swift/Demangling/TypeDecoder.h

@@ -94,7 +94,7 @@ enum class ImplParameterDifferentiability {
   NotDifferentiable
 };
 
-static inline Optional<ImplParameterDifferentiability>
+static inline llvm::Optional<ImplParameterDifferentiability>
 getDifferentiabilityFromString(StringRef string) {
   if (string.empty())
     return ImplParameterDifferentiability::DifferentiableOrNotApplicable;
@@ -115,7 +115,7 @@ class ImplFunctionParam {
   using ConventionType = ImplParameterConvention;
   using DifferentiabilityType = ImplParameterDifferentiability;
 
-  static Optional<ConventionType>
+  static llvm::Optional<ConventionType>
   getConventionFromString(StringRef conventionString) {
     if (conventionString == "@in")
       return ConventionType::Indirect_In;
@@ -168,7 +168,7 @@ class ImplFunctionResult {
 public:
   using ConventionType = ImplResultConvention;
 
-  static Optional<ConventionType>
+  static llvm::Optional<ConventionType>
   getConventionFromString(StringRef conventionString) {
     if (conventionString == "@out")
       return ConventionType::Indirect;
@@ -268,8 +268,8 @@ class ImplFunctionTypeFlags {
 #if SWIFT_OBJC_INTEROP
 /// For a mangled node that refers to an Objective-C class or protocol,
 /// return the class or protocol name.
-static inline Optional<StringRef> getObjCClassOrProtocolName(
-    NodePointer node) {
+static inline llvm::Optional<StringRef>
+getObjCClassOrProtocolName(NodePointer node) {
   if (node->getKind() != Demangle::Node::Kind::Class &&
       node->getKind() != Demangle::Node::Kind::Protocol)
     return None;
@@ -435,7 +435,7 @@ class TypeDecoder {
     case NodeKind::Metatype:
     case NodeKind::ExistentialMetatype: {
       unsigned i = 0;
-      Optional<ImplMetatypeRepresentation> repr;
+      llvm::Optional<ImplMetatypeRepresentation> repr;
 
       // Handle lowered metatypes in a hackish way. If the representation
       // was not thin, force the resulting typeref to have a non-empty
@@ -650,7 +650,7 @@ class TypeDecoder {
         }
       }
 
-      Optional<ImplFunctionResult<BuiltType>> errorResult;
+      llvm::Optional<ImplFunctionResult<BuiltType>> errorResult;
       switch (errorResults.size()) {
       case 0:
         break;
@@ -905,7 +905,7 @@ class TypeDecoder {
       return true;
 
     StringRef conventionString = node->getChild(0)->getText();
-    Optional<typename T::ConventionType> convention =
+    llvm::Optional<typename T::ConventionType> convention =
         T::getConventionFromString(conventionString);
     if (!convention)
       return true;
@@ -1072,8 +1072,8 @@ class TypeDecoder {
       return true;
     };
 
-    auto decodeParam = [&](NodePointer paramNode)
-        -> Optional<FunctionParam<BuiltType>> {
+    auto decodeParam =
+        [&](NodePointer paramNode) -> llvm::Optional<FunctionParam<BuiltType>> {
       if (paramNode->getKind() != NodeKind::TupleElement)
         return None;