mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
2c7858bfb2
This will be used to resolve properties and method calls on objects with
dynamic-lookup ("id") type. For now, this is tested in swift-ide-test
by using the -dynamic-lookup-completion option and providing a
-code-completion-token value.
Caveats/TODOs:
- As before, since we're using the global method pool, this isn't scoped by
module. We could do a per-module filter, but I don't know if that will
actually buy us much.
- Again, Clang's method pool does not include methods from protocols.
- Lookup by selector name cannot find properties with a customized getter
name. <rdar://problem/14776565>
- The Clang-side method pool is keyed by selector, but Swift wants to look
things up by method name, which maps to the first selector piece, so we
end up having to do a scan of all the selectors in the pool.
Swift SVN r7330
114 lines
4.2 KiB
C++
114 lines
4.2 KiB
C++
//===--- 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"
|
|
|
|
namespace swift {
|
|
class ASTContext;
|
|
class Module;
|
|
class ModuleFile;
|
|
|
|
/// \brief Imports serialized Swift modules into an ASTContext.
|
|
class SerializedModuleLoader : public ModuleLoader {
|
|
private:
|
|
ASTContext &Ctx;
|
|
|
|
/// 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 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 getReexportedModules(
|
|
const Module *module,
|
|
SmallVectorImpl<Module::ImportedModule> &exports) 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;
|
|
};
|
|
|
|
} // end namespace swift
|
|
|
|
#endif
|