Merge remote-tracking branch 'apple/master' into master-rebranch

Author: nkcsgexi

include/swift/AST/ASTContext.h

@@ -214,7 +214,9 @@ class ASTContext final {
   void operator=(const ASTContext&) = delete;
 
   ASTContext(LangOptions &langOpts, TypeCheckerOptions &typeckOpts,
-             SearchPathOptions &SearchPathOpts, SourceManager &SourceMgr,
+             SearchPathOptions &SearchPathOpts,
+             ClangImporterOptions &ClangImporterOpts,
+             SourceManager &SourceMgr,
              DiagnosticEngine &Diags);
 
 public:
@@ -228,6 +230,7 @@ class ASTContext final {
 
   static ASTContext *get(LangOptions &langOpts, TypeCheckerOptions &typeckOpts,
                          SearchPathOptions &SearchPathOpts,
+                         ClangImporterOptions &ClangImporterOpts,
                          SourceManager &SourceMgr, DiagnosticEngine &Diags);
   ~ASTContext();
 
@@ -246,6 +249,9 @@ class ASTContext final {
   /// The search path options used by this AST context.
   SearchPathOptions &SearchPathOpts;
 
+  /// The clang importer options used by this AST context.
+  ClangImporterOptions &ClangImporterOpts;
+
   /// The source manager object.
   SourceManager &SourceMgr;
 

include/swift/AST/Decl.h

@@ -3886,7 +3886,7 @@ class ClassDecl final : public NominalTypeDecl {
 
   friend class SuperclassDeclRequest;
   friend class SuperclassTypeRequest;
-  friend class EmittedMembersRequest;
+  friend class SemanticMembersRequest;
   friend class HasMissingDesignatedInitializersRequest;
   friend class InheritsSuperclassInitializersRequest;
 
@@ -4074,10 +4074,6 @@ class ClassDecl final : public NominalTypeDecl {
   /// Record the presence of an @objc method with the given selector.
   void recordObjCMethod(AbstractFunctionDecl *method, ObjCSelector selector);
 
-  /// Get all the members of this class, synthesizing any implicit members
-  /// that appear in the vtable if needed.
-  ArrayRef<Decl *> getEmittedMembers() const;
-
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Class;

include/swift/AST/DeclContext.h

@@ -783,6 +783,16 @@ class IterableDeclContext {
   /// Retrieve the set of members in this context.
   DeclRange getMembers() const;
 
+  /// Get the members that were syntactically present in the source code,
+  /// and will not contain any members that are implicitly synthesized by
+  /// the implementation.
+  ArrayRef<Decl *> getParsedMembers() const;
+
+  /// Get all the members that are semantically within this context,
+  /// including any implicitly-synthesized members.
+  /// The resulting list of members will be stable across translation units.
+  ArrayRef<Decl *> getSemanticMembers() const;
+
   /// Retrieve the set of members in this context without loading any from the
   /// associated lazy loader; this should only be used as part of implementing
   /// abstractions on top of member loading, such as a name lookup table.

include/swift/AST/DiagnosticsFrontend.def

@@ -328,11 +328,11 @@ ERROR(error_optimization_remark_pattern, none, "%0 in '%1'",
       (StringRef, StringRef))
 
 ERROR(error_invalid_debug_prefix_map, none,
-      "invalid argument '%0' to -debug-prefix-map; it must be of the form "
-      "'original=remapped'", (StringRef))
+      "values for '-debug-prefix-map' must be in the format 'original=remapped'"
+      ", but '%0' was provided", (StringRef))
 ERROR(error_invalid_coverage_prefix_map, none,
-      "invalid argument '%0' to -coverage-prefix-map; it must be of the form "
-      "'original=remapped'", (StringRef))
+      "values for '-coverage-prefix-map' must be in the format "
+      "'original=remapped', but '%0' was provided", (StringRef))
 
 
 ERROR(error_unable_to_write_swift_ranges_file, none,

include/swift/AST/SILOptions.h

@@ -128,6 +128,11 @@ class SILOptions {
   /// Assume that code will be executed in a single-threaded environment.
   bool AssumeSingleThreaded = false;
 
+  /// Turn @inline(__always) attributes into no-ops.
+  ///
+  /// For experimentation around code size reduction.
+  bool IgnoreAlwaysInline = false;
+
   /// Indicates which sanitizer is turned on.
   OptionSet<SanitizerKind> Sanitizers;
 

include/swift/AST/TypeCheckRequests.h

@@ -1080,9 +1080,9 @@ class SynthesizeAccessorRequest :
   void cacheResult(AccessorDecl *value) const;
 };
 
-class EmittedMembersRequest :
-    public SimpleRequest<EmittedMembersRequest,
-                         ArrayRef<Decl *>(ClassDecl *),
+class SemanticMembersRequest :
+    public SimpleRequest<SemanticMembersRequest,
+                         ArrayRef<Decl *>(IterableDeclContext *),
                          RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
@@ -1092,7 +1092,7 @@ class EmittedMembersRequest :
 
   // Evaluation.
   ArrayRef<Decl *>
-  evaluate(Evaluator &evaluator, ClassDecl *classDecl) const;
+  evaluate(Evaluator &evaluator, IterableDeclContext *idc) const;
 
 public:
   bool isCached() const { return true; }

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -65,8 +65,8 @@ SWIFT_REQUEST(TypeChecker, TypeEraserHasViableInitRequest,
 SWIFT_REQUEST(TypeChecker, DynamicallyReplacedDeclRequest,
               ValueDecl *(ValueDecl *),
               Cached, NoLocationInfo)
-SWIFT_REQUEST(TypeChecker, EmittedMembersRequest, ArrayRef<Decl *>(ClassDecl *),
-              Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, SemanticMembersRequest,
+              ArrayRef<Decl *>(IterableDeclContext *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, EnumRawValuesRequest,
               evaluator::SideEffect (EnumDecl *, TypeResolutionStage),
               SeparatelyCached, NoLocationInfo)

include/swift/Basic/LangOptions.h

@@ -577,6 +577,115 @@ namespace swift {
     /// parameters of closures.
     bool EnableOneWayClosureParameters = false;
   };
+
+  /// Options for controlling the behavior of the Clang importer.
+  class ClangImporterOptions final {
+  public:
+    /// The module cache path which the Clang importer should use.
+    std::string ModuleCachePath;
+
+    /// Extra arguments which should be passed to the Clang importer.
+    std::vector<std::string> ExtraArgs;
+
+    /// A directory for overriding Clang's resource directory.
+    std::string OverrideResourceDir;
+
+    /// The target CPU to compile for.
+    ///
+    /// Equivalent to Clang's -mcpu=.
+    std::string TargetCPU;
+
+    /// The path to which we should store indexing data, if any.
+    std::string IndexStorePath;
+
+    /// The bridging header or PCH that will be imported.
+    std::string BridgingHeader;
+
+    /// When automatically generating a precompiled header from the bridging
+    /// header, place it in this directory.
+    std::string PrecompiledHeaderOutputDir;
+
+    /// The optimizaton setting.  This doesn't typically matter for
+    /// import, but it can affect Clang's IR generation of static functions.
+    std::string Optimization;
+
+    /// Disable validating the persistent PCH.
+    bool PCHDisableValidation = false;
+
+    /// \see Mode
+    enum class Modes : uint8_t {
+      /// Set up Clang for importing modules into Swift and generating IR from
+      /// Swift code.
+      Normal,
+      /// Set up Clang for backend compilation only.
+      EmbedBitcode,
+      /// Set up Clang to emit a precompiled module from a C/Objective-C module
+      /// map or dump debugging info about a precompiled module.
+      PrecompiledModule
+    };
+
+    /// Controls how Clang is initially set up.
+    Modes Mode = Modes::Normal;
+
+    /// When set, preserves more information during import.
+    ///
+    /// Also \em disables some information that is only needed for object file
+    /// generation.
+    bool DetailedPreprocessingRecord = false;
+
+    /// If true, Clang diagnostics will be dumped to stderr using Clang's
+    /// diagnostic printer as well as being passed to Swift's diagnostic engine.
+    bool DumpClangDiagnostics = false;
+
+    /// If true, forward declarations will be imported using unavailable types
+    /// instead of dropped altogether when possible.
+    bool ImportForwardDeclarations = false;
+
+    /// Whether to use the import as member inference system
+    ///
+    /// When importing a global, try to infer whether we can import it as a
+    /// member of some type instead. This includes inits, computed properties,
+    /// and methods.
+    bool InferImportAsMember = false;
+
+    /// If true ignore the swift bridged attribute.
+    bool DisableSwiftBridgeAttr = false;
+
+    /// When set, don't look for or load overlays.
+    bool DisableOverlayModules = false;
+
+    /// When set, don't enforce warnings with -Werror.
+    bool DebuggerSupport = false;
+
+    /// When set, ClangImporter is disabled, and all requests go to the
+    /// DWARFImporter delegate.
+    bool DisableSourceImport = false;
+
+    /// When set, use ExtraArgs alone to configure clang instance because ExtraArgs
+    /// contains the full option set.
+    bool ExtraArgsOnly = false;
+
+    /// Return a hash code of any components from these options that should
+    /// contribute to a Swift Bridging PCH hash.
+    llvm::hash_code getPCHHashComponents() const {
+      using llvm::hash_combine;
+      using llvm::hash_combine_range;
+
+      return hash_combine(ModuleCachePath,
+                          hash_combine_range(ExtraArgs.begin(), ExtraArgs.end()),
+                          OverrideResourceDir,
+                          TargetCPU,
+                          BridgingHeader,
+                          PrecompiledHeaderOutputDir,
+                          static_cast<uint8_t>(Mode),
+                          DetailedPreprocessingRecord,
+                          ImportForwardDeclarations,
+                          InferImportAsMember,
+                          DisableSwiftBridgeAttr,
+                          DisableOverlayModules);
+    }
+  };
+
 } // end namespace swift
 
 #endif // SWIFT_BASIC_LANGOPTIONS_H

include/swift/ClangImporter/ClangImporter.h

@@ -115,7 +115,7 @@ class ClangImporter final : public ClangModuleLoader {
 private:
   Implementation &Impl;
 
-  ClangImporter(ASTContext &ctx, const ClangImporterOptions &clangImporterOpts,
+  ClangImporter(ASTContext &ctx,
                 DependencyTracker *tracker,
                 DWARFImporterDelegate *dwarfImporterDelegate);
 
@@ -137,8 +137,6 @@ class ClangImporter final : public ClangModuleLoader {
   /// \param ctx The ASTContext into which the module will be imported.
   /// The ASTContext's SearchPathOptions will be used for the Clang importer.
   ///
-  /// \param importerOpts The options to use for the Clang importer.
-  ///
   /// \param swiftPCHHash A hash of Swift's various options in a compiler
   /// invocation, used to create a unique Bridging PCH if requested.
   ///
@@ -150,12 +148,12 @@ class ClangImporter final : public ClangModuleLoader {
   /// \returns a new Clang module importer, or null (with a diagnostic) if
   /// an error occurred.
   static std::unique_ptr<ClangImporter>
-  create(ASTContext &ctx, const ClangImporterOptions &importerOpts,
+  create(ASTContext &ctx,
          std::string swiftPCHHash = "", DependencyTracker *tracker = nullptr,
          DWARFImporterDelegate *dwarfImporterDelegate = nullptr);
 
   static std::vector<std::string>
-  getClangArguments(ASTContext &ctx, const ClangImporterOptions &importerOpts);
+  getClangArguments(ASTContext &ctx);
 
   static std::unique_ptr<clang::CompilerInvocation>
   createClangInvocation(ClangImporter *importer,
@@ -474,7 +472,6 @@ class ClangImporter final : public ClangModuleLoader {
 
   bool isSerializable(const clang::Type *type,
                       bool checkCanonical) const override;
-  ArrayRef<std::string> getExtraClangArgs() const;
 };
 
 ImportDecl *createImportDecl(ASTContext &Ctx, DeclContext *DC, ClangNode ClangN,