mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
928cc6c83e
The imported top-level module inherits the imports of all its (transitive) submodules. Since multiple submodules can import the same modules these need to be deduplicated to avoid redundant work.
94 lines
3.0 KiB
C++
94 lines
3.0 KiB
C++
//===--- Located.h - Source Location and Associated Value ----------*- C++ -*-===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2019 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Provides a currency data type Located<T> that should be used instead
|
|
// of std::pair<T, SourceLoc>.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
#ifndef SWIFT_BASIC_LOCATED_H
|
|
#define SWIFT_BASIC_LOCATED_H
|
|
#include "swift/Basic/Debug.h"
|
|
#include "swift/Basic/LLVM.h"
|
|
#include "swift/Basic/SourceLoc.h"
|
|
|
|
namespace swift {
|
|
|
|
/// A currency type for keeping track of items which were found in the source code.
|
|
/// Several parts of the compiler need to keep track of a `SourceLoc` corresponding
|
|
/// to an item, in case they need to report some diagnostics later. For example,
|
|
/// the ClangImporter needs to keep track of where imports were originally written.
|
|
/// Located makes it easy to do so while making the code more readable, compared to
|
|
/// using `std::pair`.
|
|
template <typename T>
|
|
struct Located {
|
|
/// The main item whose source location is being tracked.
|
|
T Item;
|
|
|
|
/// The original source location from which the item was parsed.
|
|
SourceLoc Loc;
|
|
|
|
Located() : Item(), Loc() {}
|
|
|
|
Located(T Item, SourceLoc loc) : Item(Item), Loc(loc) {}
|
|
|
|
SWIFT_DEBUG_DUMP;
|
|
void dump(raw_ostream &os) const;
|
|
};
|
|
|
|
template <typename T>
|
|
bool operator ==(const Located<T> &lhs, const Located<T> &rhs) {
|
|
return lhs.Item == rhs.Item && lhs.Loc == rhs.Loc;
|
|
}
|
|
|
|
} // end namespace swift
|
|
|
|
namespace llvm {
|
|
|
|
template <typename T, typename Enable> struct DenseMapInfo;
|
|
|
|
template<typename T>
|
|
struct DenseMapInfo<swift::Located<T>> {
|
|
|
|
static inline swift::Located<T> getEmptyKey() {
|
|
return swift::Located<T>(DenseMapInfo<T>::getEmptyKey(),
|
|
DenseMapInfo<swift::SourceLoc>::getEmptyKey());
|
|
}
|
|
|
|
static inline swift::Located<T> getTombstoneKey() {
|
|
return swift::Located<T>(DenseMapInfo<T>::getTombstoneKey(),
|
|
DenseMapInfo<swift::SourceLoc>::getTombstoneKey());
|
|
}
|
|
|
|
static unsigned getHashValue(const swift::Located<T> &LocatedVal) {
|
|
return detail::combineHashValue(DenseMapInfo<T>::getHashValue(LocatedVal.Item),
|
|
DenseMapInfo<swift::SourceLoc>::getHashValue(LocatedVal.Loc));
|
|
}
|
|
|
|
static bool isEqual(const swift::Located<T> &LHS, const swift::Located<T> &RHS) {
|
|
return DenseMapInfo<T>::isEqual(LHS.Item, RHS.Item) &&
|
|
DenseMapInfo<T>::isEqual(LHS.Loc, RHS.Loc);
|
|
}
|
|
};
|
|
} // namespace llvm
|
|
|
|
namespace swift {
|
|
template<typename T>
|
|
llvm::hash_code hash_value(const Located<T> &LocatedVal) {
|
|
return llvm::DenseMapInfo<Located<T>>::getHashValue(LocatedVal);
|
|
}
|
|
} // namespace swift
|
|
|
|
|
|
#endif // SWIFT_BASIC_LOCATED_H
|