mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
7ec4c4fef3
Also, suggest "xcrun swiftc" instead of "xcrun swift" on OS X, since "swift" already infers SDKs and we shouldn't get into this situation. (We shouldn't get into it on non-OS-X either thanks to the previous commit, but just in case.) rdar://problem/22440615 Swift SVN r31535
321 lines
11 KiB
C++
321 lines
11 KiB
C++
//===--- NameBinding.cpp - Name Binding -----------------------------------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements name binding for Swift.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "swift/Subsystems.h"
|
|
#include "swift/AST/NameLookup.h"
|
|
#include "swift/AST/AST.h"
|
|
#include "swift/AST/DiagnosticsSema.h"
|
|
#include "swift/AST/ASTWalker.h"
|
|
#include "swift/AST/ModuleLoader.h"
|
|
#include "swift/ClangImporter/ClangModule.h"
|
|
#include "clang/Basic/Module.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/TinyPtrVector.h"
|
|
#include "llvm/ADT/Twine.h"
|
|
#include "llvm/Support/SaveAndRestore.h"
|
|
#include "llvm/Support/Path.h"
|
|
#include <algorithm>
|
|
#include <system_error>
|
|
using namespace swift;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// NameBinder
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
using ImportedModule = Module::ImportedModule;
|
|
using ImportOptions = SourceFile::ImportOptions;
|
|
|
|
namespace {
|
|
class NameBinder {
|
|
public:
|
|
SourceFile &SF;
|
|
ASTContext &Context;
|
|
|
|
NameBinder(SourceFile &SF) : SF(SF), Context(SF.getASTContext()) {}
|
|
|
|
template<typename ...ArgTypes>
|
|
InFlightDiagnostic diagnose(ArgTypes &&...Args) {
|
|
return Context.Diags.diagnose(std::forward<ArgTypes>(Args)...);
|
|
}
|
|
|
|
void addImport(
|
|
SmallVectorImpl<std::pair<ImportedModule, ImportOptions>> &imports,
|
|
ImportDecl *ID);
|
|
|
|
/// Load a module referenced by an import statement.
|
|
///
|
|
/// Returns null if no module can be loaded.
|
|
Module *getModule(ArrayRef<std::pair<Identifier,SourceLoc>> ModuleID);
|
|
};
|
|
}
|
|
|
|
Module *
|
|
NameBinder::getModule(ArrayRef<std::pair<Identifier, SourceLoc>> modulePath) {
|
|
assert(!modulePath.empty());
|
|
auto moduleID = modulePath[0];
|
|
|
|
// The Builtin module cannot be explicitly imported unless we're a .sil file
|
|
// or in the REPL.
|
|
if ((SF.Kind == SourceFileKind::SIL || SF.Kind == SourceFileKind::REPL) &&
|
|
moduleID.first == Context.TheBuiltinModule->getName())
|
|
return Context.TheBuiltinModule;
|
|
|
|
// If the imported module name is the same as the current module,
|
|
// skip the Swift module loader and use the Clang module loader instead.
|
|
// This allows a Swift module to extend a Clang module of the same name.
|
|
//
|
|
// FIXME: We'd like to only use this in SIL mode, but unfortunately we use it
|
|
// for our fake overlays as well.
|
|
if (moduleID.first == SF.getParentModule()->getName() &&
|
|
modulePath.size() == 1) {
|
|
if (auto importer = Context.getClangModuleLoader())
|
|
return importer->loadModule(moduleID.second, modulePath);
|
|
return nullptr;
|
|
}
|
|
|
|
return Context.getModule(modulePath);
|
|
}
|
|
|
|
/// Returns true if a decl with the given \p actual kind can legally be
|
|
/// imported via the given \p expected kind.
|
|
static bool isCompatibleImportKind(ImportKind expected, ImportKind actual) {
|
|
if (expected == actual)
|
|
return true;
|
|
if (expected != ImportKind::Type)
|
|
return false;
|
|
|
|
switch (actual) {
|
|
case ImportKind::Module:
|
|
llvm_unreachable("module imports do not bring in decls");
|
|
case ImportKind::Type:
|
|
llvm_unreachable("individual decls cannot have abstract import kind");
|
|
case ImportKind::Struct:
|
|
case ImportKind::Class:
|
|
case ImportKind::Enum:
|
|
return true;
|
|
case ImportKind::Protocol:
|
|
case ImportKind::Var:
|
|
case ImportKind::Func:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static const char *getImportKindString(ImportKind kind) {
|
|
switch (kind) {
|
|
case ImportKind::Module:
|
|
llvm_unreachable("module imports do not bring in decls");
|
|
case ImportKind::Type:
|
|
return "typealias";
|
|
case ImportKind::Struct:
|
|
return "struct";
|
|
case ImportKind::Class:
|
|
return "class";
|
|
case ImportKind::Enum:
|
|
return "enum";
|
|
case ImportKind::Protocol:
|
|
return "protocol";
|
|
case ImportKind::Var:
|
|
return "var";
|
|
case ImportKind::Func:
|
|
return "func";
|
|
}
|
|
}
|
|
|
|
static bool shouldImportSelfImportClang(const ImportDecl *ID,
|
|
const SourceFile &SF) {
|
|
// FIXME: We use '@exported' for fake overlays in testing.
|
|
if (ID->isExported())
|
|
return true;
|
|
if (SF.Kind == SourceFileKind::SIL)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void NameBinder::addImport(
|
|
SmallVectorImpl<std::pair<ImportedModule, ImportOptions>> &imports,
|
|
ImportDecl *ID) {
|
|
if (ID->getModulePath().front().first == SF.getParentModule()->getName() &&
|
|
ID->getModulePath().size() == 1 && !shouldImportSelfImportClang(ID, SF)) {
|
|
// If the imported module name is the same as the current module,
|
|
// produce an error.
|
|
Context.Diags.diagnose(ID, diag::sema_import_current_module);
|
|
return;
|
|
}
|
|
|
|
Module *M = getModule(ID->getModulePath());
|
|
if (!M) {
|
|
SmallString<64> modulePathStr;
|
|
interleave(ID->getModulePath(),
|
|
[&](ImportDecl::AccessPathElement elem) {
|
|
modulePathStr += elem.first.str();
|
|
},
|
|
[&] { modulePathStr += "."; });
|
|
|
|
auto diagKind = diag::sema_no_import;
|
|
if (SF.Kind == SourceFileKind::REPL || Context.LangOpts.DebuggerSupport)
|
|
diagKind = diag::sema_no_import_repl;
|
|
diagnose(ID->getLoc(), diagKind, modulePathStr);
|
|
|
|
if (Context.SearchPathOpts.SDKPath.empty() &&
|
|
llvm::Triple(llvm::sys::getProcessTriple()).isMacOSX()) {
|
|
diagnose(SourceLoc(), diag::sema_no_import_no_sdk);
|
|
diagnose(SourceLoc(), diag::sema_no_import_no_sdk_xcrun);
|
|
}
|
|
return;
|
|
}
|
|
|
|
ID->setModule(M);
|
|
|
|
Module *topLevelModule;
|
|
if (ID->getModulePath().size() == 1) {
|
|
topLevelModule = M;
|
|
} else {
|
|
// If we imported a submodule, import the top-level module as well.
|
|
Identifier topLevelName = ID->getModulePath().front().first;
|
|
topLevelModule = Context.getLoadedModule(topLevelName);
|
|
assert(topLevelModule && "top-level module missing");
|
|
}
|
|
|
|
auto *testableAttr = ID->getAttrs().getAttribute<TestableAttr>();
|
|
if (testableAttr && !topLevelModule->isTestingEnabled() &&
|
|
Context.LangOpts.EnableTestableAttrRequiresTestableModule) {
|
|
diagnose(ID->getModulePath().front().second, diag::module_not_testable,
|
|
topLevelModule->getName());
|
|
testableAttr->setInvalid();
|
|
}
|
|
|
|
ImportOptions options;
|
|
if (ID->isExported())
|
|
options |= SourceFile::ImportFlags::Exported;
|
|
if (testableAttr)
|
|
options |= SourceFile::ImportFlags::Testable;
|
|
imports.push_back({ { ID->getDeclPath(), M }, options });
|
|
|
|
if (topLevelModule != M)
|
|
imports.push_back({ { ID->getDeclPath(), topLevelModule }, options });
|
|
|
|
if (ID->getImportKind() != ImportKind::Module) {
|
|
// If we're importing a specific decl, validate the import kind.
|
|
using namespace namelookup;
|
|
auto declPath = ID->getDeclPath();
|
|
|
|
// FIXME: Doesn't handle scoped testable imports correctly.
|
|
assert(declPath.size() == 1 && "can't handle sub-decl imports");
|
|
SmallVector<ValueDecl *, 8> decls;
|
|
lookupInModule(topLevelModule, declPath, declPath.front().first, decls,
|
|
NLKind::QualifiedLookup, ResolutionKind::Overloadable,
|
|
/*resolver*/nullptr, &SF);
|
|
|
|
if (decls.empty()) {
|
|
diagnose(ID, diag::no_decl_in_module)
|
|
.highlight(SourceRange(declPath.front().second,
|
|
declPath.back().second));
|
|
return;
|
|
}
|
|
|
|
ID->setDecls(Context.AllocateCopy(decls));
|
|
|
|
Optional<ImportKind> actualKind = ImportDecl::findBestImportKind(decls);
|
|
if (!actualKind.hasValue()) {
|
|
// FIXME: print entire module name?
|
|
diagnose(ID, diag::ambiguous_decl_in_module,
|
|
declPath.front().first, M->getName());
|
|
for (auto next : decls)
|
|
diagnose(next, diag::found_candidate);
|
|
|
|
} else if (!isCompatibleImportKind(ID->getImportKind(), *actualKind)) {
|
|
diagnose(ID, diag::imported_decl_is_wrong_kind,
|
|
declPath.front().first,
|
|
getImportKindString(ID->getImportKind()),
|
|
static_cast<unsigned>(*actualKind))
|
|
.fixItReplace(SourceRange(ID->getKindLoc()),
|
|
getImportKindString(*actualKind));
|
|
|
|
if (decls.size() == 1)
|
|
diagnose(decls.front(), diag::decl_declared_here,
|
|
decls.front()->getName());
|
|
}
|
|
}
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// performNameBinding
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
template<typename OP_DECL>
|
|
static void insertOperatorDecl(NameBinder &Binder,
|
|
SourceFile::OperatorMap<OP_DECL*> &Operators,
|
|
OP_DECL *OpDecl) {
|
|
auto previousDecl = Operators.find(OpDecl->getName());
|
|
if (previousDecl != Operators.end()) {
|
|
Binder.diagnose(OpDecl->getLoc(), diag::operator_redeclared);
|
|
Binder.diagnose(previousDecl->second.getPointer(),
|
|
diag::previous_operator_decl);
|
|
return;
|
|
}
|
|
|
|
// FIXME: The second argument indicates whether the given operator is visible
|
|
// outside the current file.
|
|
Operators[OpDecl->getName()] = { OpDecl, true };
|
|
}
|
|
|
|
/// performNameBinding - Once parsing is complete, this walks the AST to
|
|
/// resolve names and do other top-level validation.
|
|
///
|
|
/// At this parsing has been performed, but we still have UnresolvedDeclRefExpr
|
|
/// nodes for unresolved value names, and we may have unresolved type names as
|
|
/// well. This handles import directives and forward references.
|
|
void swift::performNameBinding(SourceFile &SF, unsigned StartElem) {
|
|
// Make sure we skip adding the standard library imports if the
|
|
// source file is empty.
|
|
if (SF.ASTStage == SourceFile::NameBound || SF.Decls.empty()) {
|
|
SF.ASTStage = SourceFile::NameBound;
|
|
return;
|
|
}
|
|
|
|
// Reset the name lookup cache so we find new decls.
|
|
// FIXME: This is inefficient.
|
|
SF.clearLookupCache();
|
|
|
|
NameBinder Binder(SF);
|
|
|
|
SmallVector<std::pair<ImportedModule, ImportOptions>, 8> ImportedModules;
|
|
|
|
// Do a prepass over the declarations to find and load the imported modules
|
|
// and map operator decls.
|
|
for (auto D : llvm::makeArrayRef(SF.Decls).slice(StartElem)) {
|
|
if (ImportDecl *ID = dyn_cast<ImportDecl>(D)) {
|
|
Binder.addImport(ImportedModules, ID);
|
|
} else if (auto *OD = dyn_cast<PrefixOperatorDecl>(D)) {
|
|
insertOperatorDecl(Binder, SF.PrefixOperators, OD);
|
|
} else if (auto *OD = dyn_cast<PostfixOperatorDecl>(D)) {
|
|
insertOperatorDecl(Binder, SF.PostfixOperators, OD);
|
|
} else if (auto *OD = dyn_cast<InfixOperatorDecl>(D)) {
|
|
insertOperatorDecl(Binder, SF.InfixOperators, OD);
|
|
}
|
|
}
|
|
|
|
SF.addImports(ImportedModules);
|
|
|
|
// FIXME: This algorithm has quadratic memory usage. (In practice,
|
|
// import statements after the first "chunk" should be rare, though.)
|
|
// FIXME: Can we make this more efficient?
|
|
|
|
SF.ASTStage = SourceFile::NameBound;
|
|
verify(SF);
|
|
}
|
|
|