swift-mirror/include/swift/Serialization/SerializedModuleLoader.h

//===--- SerializedModuleLoader.h - Import Swift modules --------*- c++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See http://swift.org/LICENSE.txt for license information
// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//

#ifndef SWIFT_SERIALIZATION_MODULELOADER_H
#define SWIFT_SERIALIZATION_MODULELOADER_H

#include "swift/AST/ModuleLoader.h"
#include "llvm/ADT/OwningPtr.h"
#include "llvm/Support/MemoryBuffer.h"
#include <map>

namespace swift {
class ASTContext;
class Module;
class ModuleFile;

/// \brief Imports serialized Swift modules into an ASTContext.
class SerializedModuleLoader : public ModuleLoader {
private:
  ASTContext &Ctx;
  std::map<std::string, std::unique_ptr<llvm::MemoryBuffer> > MemoryBuffers;
  /// A { module, generation # } pair.
  using LoadedModulePair = std::pair<std::unique_ptr<ModuleFile>, unsigned>;
  std::vector<LoadedModulePair> LoadedModuleFiles;

  explicit SerializedModuleLoader(ASTContext &ctx);

public:
  /// \brief Create a new importer that can load serialized Swift modules
  /// into the given ASTContext.
  static SerializedModuleLoader *create(ASTContext &ctx) {
    return new SerializedModuleLoader(ctx);
  }

  ~SerializedModuleLoader();

  SerializedModuleLoader(const SerializedModuleLoader &) = delete;
  SerializedModuleLoader(SerializedModuleLoader &&) = delete;
  SerializedModuleLoader &operator=(const SerializedModuleLoader &) = delete;
  SerializedModuleLoader &operator=(SerializedModuleLoader &&) = delete;

  /// \brief Import a module with the given module path.
  ///
  /// \param importLoc The location of the 'import' keyword.
  ///
  /// \param path A sequence of (identifier, location) pairs that denote
  /// the dotted module name to load, e.g., AppKit.NSWindow.
  ///
  /// \returns the module referenced, if it could be loaded. Otherwise,
  /// emits a diagnostic and returns NULL.
  virtual Module *
  loadModule(SourceLoc importLoc, Module::AccessPathTy path) override;

  /// \brief Register a memory buffer that contains the serialized
  /// module for the given access path. This API is intended to be
  /// used by LLDB to add swiftmodules discovered in the __apple_ast
  /// section of a Mach-O file to the search path.
  /// FIXME: make this an actual access *path* once submodules are designed.
  void registerMemoryBuffer(StringRef AccessPath,
                            std::unique_ptr<llvm::MemoryBuffer> input) {
    MemoryBuffers[AccessPath].reset(input.release());
  }

  /// \brief Povided a memory buffer with an entire Mach-O __apple_ast
  /// section, this function makes memory buffer copies of all swift
  /// modules found in it and registers them using
  /// registerMemoryBuffer() so they can be found by loadModule(). The
  /// the access path of all modules found in the section is appended
  /// to the vector foundModules.
  /// \return true if successful.
  bool addASTSection(std::unique_ptr<llvm::MemoryBuffer> data,
                     SmallVectorImpl<std::string> &foundModules);

  /// \brief Look for declarations associated with the given name.
  ///
  /// \param module The module to search.
  ///
  /// \param accessPath The access path used to refer to the name within this
  /// (top-level) module.
  ///
  /// \param name The name we're searching for.
  ///
  /// \param lookupKind Whether we're performing qualified vs. unqualified
  /// lookup.
  ///
  /// \param result Will be populated with the results of name lookup.
  virtual void lookupValue(Module *module,
                           Module::AccessPathTy accessPath, Identifier name,
                           NLKind lookupKind,
                           SmallVectorImpl<ValueDecl*> &result) override;

  /// \brief Look for a declaration of the given operator.
  ///
  /// \returns The operator decl, or null if this module does not define the
  /// operator in question.
  virtual OperatorDecl *lookupOperator(Module *module, Identifier name,
                                       DeclKind fixity) override;

  virtual void getImportedModules(
    const Module *module,
    SmallVectorImpl<Module::ImportedModule> &imports,
    bool includePrivate) override;

  virtual void lookupVisibleDecls(const Module *module,
                                  Module::AccessPathTy accessPath,
                                  VisibleDeclConsumer &consumer,
                                  NLKind lookupKind) override;

  virtual void lookupClassMembers(const Module *module,
                                  Module::AccessPathTy accessPath,
                                  VisibleDeclConsumer &consumer) override;

  virtual void lookupClassMember(const Module *module,
                                 Module::AccessPathTy accessPath,
                                 Identifier name,
                                 SmallVectorImpl<ValueDecl*> &results) override;

  virtual void loadExtensions(NominalTypeDecl *nominal,
                              unsigned previousGeneration) override;

  virtual void loadDeclsConformingTo(KnownProtocolKind kind,
                                     unsigned previousGeneration) override;

  virtual void getLinkLibraries(const Module *module,
                                Module::LinkLibraryCallback callback) override;
  
  virtual void getDisplayDecls(const Module *module,
                               SmallVectorImpl<Decl*> &results) override;
};

} // end namespace swift

#endif