include/swift/AST/AnyRequest.h - third_party/swift - Git at Google

 //===--- AnyRequest.h - Requests Instances ----------------------*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //
 // Copyright (c) 2014 - 2017 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
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the AnyRequest class, which describes a stored request.
 //
 //===----------------------------------------------------------------------===//

 #ifndef SWIFT_AST_ANYREQUEST_H
 #define SWIFT_AST_ANYREQUEST_H

 #include "swift/Basic/TypeID.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include <string>

 namespace llvm {
 class raw_ostream;
 }

 namespace swift {

 using llvm::hash_code;
 using llvm::hash_value;

 class DiagnosticEngine;

 /// Stores a request (for the \c Evaluator class) of any kind.
 ///
 /// Requests must be value types and provide the following API to be stored in
 /// an \c AnyRequest instance:
 ///
 ///   - Copy constructor
 ///   - Equality operator (==)
 ///   - Hashing support (hash_value)
 ///   - TypeID support (see swift/Basic/TypeID.h)
 ///   - Display support (free function):
 ///       void simple_display(llvm::raw_ostream &, const T &);
 ///   - Cycle diagnostics operations:
 ///       void diagnoseCycle(DiagnosticEngine &diags) const;
 ///       void noteCycleStep(DiagnosticEngine &diags) const;
 ///
 class AnyRequest {
   friend llvm::DenseMapInfo<swift::AnyRequest>;

   static hash_code hashForHolder(uint64_t typeID, hash_code requestHash) {
     return hash_combine(hash_value(typeID), requestHash);
   }

   /// Abstract base class used to hold the specific request kind.
   class HolderBase : public llvm::RefCountedBase<HolderBase> {
   public:
     /// The type ID of the request being stored.
     const uint64_t typeID;

     /// Hash value for the request itself.
     const hash_code hash;

   protected:
     /// Initialize base with type ID and hash code.
     HolderBase(uint64_t typeID, hash_code hash)
       : typeID(typeID), hash(AnyRequest::hashForHolder(typeID, hash)) { }

   public:
     virtual ~HolderBase();

     /// Determine whether this request is equivalent to the \c other
     /// request.
     virtual bool equals(const HolderBase &other) const = 0;

     /// Display.
     virtual void display(llvm::raw_ostream &out) const = 0;

     /// Diagnose a cycle detected for this request.
     virtual void diagnoseCycle(DiagnosticEngine &diags) const = 0;

     /// Note that this request is part of a cycle.
     virtual void noteCycleStep(DiagnosticEngine &diags) const = 0;
   };

   /// Holds a value that can be used as a request input/output.
   template<typename Request>
   class Holder final : public HolderBase {
   public:
     const Request request;

     Holder(const Request &request)
       : HolderBase(TypeID<Request>::value, hash_value(request)),
         request(request) { }

     Holder(Request &&request)
       : HolderBase(TypeID<Request>::value, hash_value(request)),
         request(std::move(request)) { }

     virtual ~Holder() { }

     /// Determine whether this request is equivalent to another.
     ///
     /// The caller guarantees that the typeIDs are the same.
     virtual bool equals(const HolderBase &other) const override {
       assert(typeID == other.typeID && "Caller should match typeIDs");
       return request == static_cast<const Holder<Request> &>(other).request;
     }

     /// Display.
     virtual void display(llvm::raw_ostream &out) const override {
       simple_display(out, request);
     }

     /// Diagnose a cycle detected for this request.
     virtual void diagnoseCycle(DiagnosticEngine &diags) const override {
       request.diagnoseCycle(diags);
     }

     /// Note that this request is part of a cycle.
     virtual void noteCycleStep(DiagnosticEngine &diags) const override {
       request.noteCycleStep(diags);
     }
   };

   /// FIXME: Inefficient. Use the low bits.
   enum class StorageKind {
     Normal,
     Empty,
     Tombstone,
   } storageKind = StorageKind::Normal;

   /// The data stored in this value.
   llvm::IntrusiveRefCntPtr<HolderBase> stored;

   AnyRequest(StorageKind storageKind) : storageKind(storageKind) {
     assert(storageKind != StorageKind::Normal);
   }

 public:
   AnyRequest(const AnyRequest &other) = default;
   AnyRequest &operator=(const AnyRequest &other) = default;

   AnyRequest(AnyRequest &&other)
       : storageKind(other.storageKind), stored(std::move(other.stored)) {
     other.storageKind = StorageKind::Empty;
   }

   AnyRequest &operator=(AnyRequest &&other) {
     storageKind = other.storageKind;
     stored = std::move(other.stored);
     other.storageKind = StorageKind::Empty;
     other.stored = nullptr;
     return *this;
   }

   // Create a local template typename `ValueType` in the template specialization
   // so that we can refer to it in the SFINAE condition as well as the body of
   // the template itself.  The SFINAE condition allows us to remove this
   // constructor from candidacy when evaluating explicit construction with an
   // instance of `AnyRequest`.  If we do not do so, we will find ourselves with
   // ambiguity with this constructor and the defined move constructor above.
   /// Construct a new instance with the given value.
   template <typename T,
             typename ValueType = typename std::remove_cv<
                 typename std::remove_reference<T>::type>::type,
             typename = typename std::enable_if<
                 !std::is_same<ValueType, AnyRequest>::value>::type>
   explicit AnyRequest(T &&value) : storageKind(StorageKind::Normal) {
     stored = llvm::IntrusiveRefCntPtr<HolderBase>(
         new Holder<ValueType>(std::forward<T>(value)));
   }

   /// Cast to a specific (known) type.
   template<typename Request>
   const Request &castTo() const {
     assert(stored->typeID == TypeID<Request>::value && "wrong type in cast");
     return static_cast<const Holder<Request> *>(stored.get())->request;
   }

   /// Try casting to a specific (known) type, returning \c nullptr on
   /// failure.
   template<typename Request>
   const Request *getAs() const {
     if (stored->typeID != TypeID<Request>::value)
       return nullptr;

     return &static_cast<const Holder<Request> *>(stored.get())->request;
   }

   /// Diagnose a cycle detected for this request.
   void diagnoseCycle(DiagnosticEngine &diags) const {
     stored->diagnoseCycle(diags);
   }

   /// Note that this request is part of a cycle.
   void noteCycleStep(DiagnosticEngine &diags) const {
     stored->noteCycleStep(diags);
   }

   /// Compare two instances for equality.
   friend bool operator==(const AnyRequest &lhs, const AnyRequest &rhs) {
     if (lhs.storageKind != rhs.storageKind) {
       return false;
     }

     if (lhs.storageKind != StorageKind::Normal)
       return true;

     if (lhs.stored->typeID != rhs.stored->typeID)
       return false;

     return lhs.stored->equals(*rhs.stored);
   }

   friend bool operator!=(const AnyRequest &lhs, const AnyRequest &rhs) {
     return !(lhs == rhs);
   }

   friend hash_code hash_value(const AnyRequest &any) {
     if (any.storageKind != StorageKind::Normal)
       return 1;

     return any.stored->hash;
   }

   friend void simple_display(llvm::raw_ostream &out, const AnyRequest &any) {
     any.stored->display(out);
   }

   /// Return the result of calling simple_display as a string.
   std::string getAsString() const;

   static AnyRequest getEmptyKey() {
     return AnyRequest(StorageKind::Empty);
   }

   static AnyRequest getTombstoneKey() {
     return AnyRequest(StorageKind::Tombstone);
   }
 };

 } // end namespace swift

 namespace llvm {
   template<>
   struct DenseMapInfo<swift::AnyRequest> {
     static inline swift::AnyRequest getEmptyKey() {
       return swift::AnyRequest::getEmptyKey();
     }
     static inline swift::AnyRequest getTombstoneKey() {
       return swift::AnyRequest::getTombstoneKey();
     }
     static unsigned getHashValue(const swift::AnyRequest &request) {
       return hash_value(request);
     }
     template <typename Request>
     static unsigned getHashValue(const Request &request) {
       return swift::AnyRequest::hashForHolder(swift::TypeID<Request>::value,
                                               hash_value(request));
     }
     static bool isEqual(const swift::AnyRequest &lhs,
                         const swift::AnyRequest &rhs) {
       return lhs == rhs;
     }
     template <typename Request>
     static bool isEqual(const Request &lhs,
                         const swift::AnyRequest &rhs) {
       if (rhs == getEmptyKey() || rhs == getTombstoneKey())
         return false;
       const Request *rhsRequest = rhs.getAs<Request>();
       if (!rhsRequest)
         return false;
       return lhs == *rhsRequest;
     }
   };

 } // end namespace llvm

 #endif // SWIFT_AST_ANYREQUEST_H
	//===--- AnyRequest.h - Requests Instances ----------------------- C++ --===//
	//
	// This source file is part of the Swift.org open source project
	//
	// Copyright (c) 2014 - 2017 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
	//
	//===----------------------------------------------------------------------===//
	//
	// This file defines the AnyRequest class, which describes a stored request.
	//
	//===----------------------------------------------------------------------===//

	#ifndef SWIFT_AST_ANYREQUEST_H
	#define SWIFT_AST_ANYREQUEST_H

	#include "swift/Basic/TypeID.h"
	#include "llvm/ADT/DenseMapInfo.h"
	#include "llvm/ADT/Hashing.h"
	#include "llvm/ADT/IntrusiveRefCntPtr.h"
	#include <string>

	namespace llvm {
	class raw_ostream;
	}

	namespace swift {

	using llvm::hash_code;
	using llvm::hash_value;

	class DiagnosticEngine;

	/// Stores a request (for the \c Evaluator class) of any kind.
	///
	/// Requests must be value types and provide the following API to be stored in
	/// an \c AnyRequest instance:
	///
	/// - Copy constructor
	/// - Equality operator (==)
	/// - Hashing support (hash_value)
	/// - TypeID support (see swift/Basic/TypeID.h)
	/// - Display support (free function):
	/// void simple_display(llvm::raw_ostream &, const T &);
	/// - Cycle diagnostics operations:
	/// void diagnoseCycle(DiagnosticEngine &diags) const;
	/// void noteCycleStep(DiagnosticEngine &diags) const;
	///
	class AnyRequest {
	friend llvm::DenseMapInfo<swift::AnyRequest>;

	static hash_code hashForHolder(uint64_t typeID, hash_code requestHash) {
	return hash_combine(hash_value(typeID), requestHash);
	}

	/// Abstract base class used to hold the specific request kind.
	class HolderBase : public llvm::RefCountedBase<HolderBase> {
	public:
	/// The type ID of the request being stored.
	const uint64_t typeID;

	/// Hash value for the request itself.
	const hash_code hash;

	protected:
	/// Initialize base with type ID and hash code.
	HolderBase(uint64_t typeID, hash_code hash)
	: typeID(typeID), hash(AnyRequest::hashForHolder(typeID, hash)) { }

	public:
	virtual ~HolderBase();

	/// Determine whether this request is equivalent to the \c other
	/// request.
	virtual bool equals(const HolderBase &other) const = 0;

	/// Display.
	virtual void display(llvm::raw_ostream &out) const = 0;

	/// Diagnose a cycle detected for this request.
	virtual void diagnoseCycle(DiagnosticEngine &diags) const = 0;

	/// Note that this request is part of a cycle.
	virtual void noteCycleStep(DiagnosticEngine &diags) const = 0;
	};

	/// Holds a value that can be used as a request input/output.
	template<typename Request>
	class Holder final : public HolderBase {
	public:
	const Request request;

	Holder(const Request &request)
	: HolderBase(TypeID<Request>::value, hash_value(request)),
	request(request) { }

	Holder(Request &&request)
	: HolderBase(TypeID<Request>::value, hash_value(request)),
	request(std::move(request)) { }

	virtual ~Holder() { }

	/// Determine whether this request is equivalent to another.
	///
	/// The caller guarantees that the typeIDs are the same.
	virtual bool equals(const HolderBase &other) const override {
	assert(typeID == other.typeID && "Caller should match typeIDs");
	return request == static_cast<const Holder<Request> &>(other).request;
	}

	/// Display.
	virtual void display(llvm::raw_ostream &out) const override {
	simple_display(out, request);
	}

	/// Diagnose a cycle detected for this request.
	virtual void diagnoseCycle(DiagnosticEngine &diags) const override {
	request.diagnoseCycle(diags);
	}

	/// Note that this request is part of a cycle.
	virtual void noteCycleStep(DiagnosticEngine &diags) const override {
	request.noteCycleStep(diags);
	}
	};

	/// FIXME: Inefficient. Use the low bits.
	enum class StorageKind {
	Normal,
	Empty,
	Tombstone,
	} storageKind = StorageKind::Normal;

	/// The data stored in this value.
	llvm::IntrusiveRefCntPtr<HolderBase> stored;

	AnyRequest(StorageKind storageKind) : storageKind(storageKind) {
	assert(storageKind != StorageKind::Normal);
	}

	public:
	AnyRequest(const AnyRequest &other) = default;
	AnyRequest &operator=(const AnyRequest &other) = default;

	AnyRequest(AnyRequest &&other)
	: storageKind(other.storageKind), stored(std::move(other.stored)) {
	other.storageKind = StorageKind::Empty;
	}

	AnyRequest &operator=(AnyRequest &&other) {
	storageKind = other.storageKind;
	stored = std::move(other.stored);
	other.storageKind = StorageKind::Empty;
	other.stored = nullptr;
	return *this;
	}

	// Create a local template typename `ValueType` in the template specialization
	// so that we can refer to it in the SFINAE condition as well as the body of
	// the template itself. The SFINAE condition allows us to remove this
	// constructor from candidacy when evaluating explicit construction with an
	// instance of `AnyRequest`. If we do not do so, we will find ourselves with
	// ambiguity with this constructor and the defined move constructor above.
	/// Construct a new instance with the given value.
	template <typename T,
	typename ValueType = typename std::remove_cv<
	typename std::remove_reference<T>::type>::type,
	typename = typename std::enable_if<
	!std::is_same<ValueType, AnyRequest>::value>::type>
	explicit AnyRequest(T &&value) : storageKind(StorageKind::Normal) {
	stored = llvm::IntrusiveRefCntPtr<HolderBase>(
	new Holder<ValueType>(std::forward<T>(value)));
	}

	/// Cast to a specific (known) type.
	template<typename Request>
	const Request &castTo() const {
	assert(stored->typeID == TypeID<Request>::value && "wrong type in cast");
	return static_cast<const Holder<Request> *>(stored.get())->request;
	}

	/// Try casting to a specific (known) type, returning \c nullptr on
	/// failure.
	template<typename Request>
	const Request *getAs() const {
	if (stored->typeID != TypeID<Request>::value)
	return nullptr;

	return &static_cast<const Holder<Request> *>(stored.get())->request;
	}

	/// Diagnose a cycle detected for this request.
	void diagnoseCycle(DiagnosticEngine &diags) const {
	stored->diagnoseCycle(diags);
	}

	/// Note that this request is part of a cycle.
	void noteCycleStep(DiagnosticEngine &diags) const {
	stored->noteCycleStep(diags);
	}

	/// Compare two instances for equality.
	friend bool operator==(const AnyRequest &lhs, const AnyRequest &rhs) {
	if (lhs.storageKind != rhs.storageKind) {
	return false;
	}

	if (lhs.storageKind != StorageKind::Normal)
	return true;

	if (lhs.stored->typeID != rhs.stored->typeID)
	return false;

	return lhs.stored->equals(*rhs.stored);
	}

	friend bool operator!=(const AnyRequest &lhs, const AnyRequest &rhs) {
	return !(lhs == rhs);
	}

	friend hash_code hash_value(const AnyRequest &any) {
	if (any.storageKind != StorageKind::Normal)
	return 1;

	return any.stored->hash;
	}

	friend void simple_display(llvm::raw_ostream &out, const AnyRequest &any) {
	any.stored->display(out);
	}

	/// Return the result of calling simple_display as a string.
	std::string getAsString() const;

	static AnyRequest getEmptyKey() {
	return AnyRequest(StorageKind::Empty);
	}

	static AnyRequest getTombstoneKey() {
	return AnyRequest(StorageKind::Tombstone);
	}
	};

	} // end namespace swift

	namespace llvm {
	template<>
	struct DenseMapInfo<swift::AnyRequest> {
	static inline swift::AnyRequest getEmptyKey() {
	return swift::AnyRequest::getEmptyKey();
	}
	static inline swift::AnyRequest getTombstoneKey() {
	return swift::AnyRequest::getTombstoneKey();
	}
	static unsigned getHashValue(const swift::AnyRequest &request) {
	return hash_value(request);
	}
	template <typename Request>
	static unsigned getHashValue(const Request &request) {
	return swift::AnyRequest::hashForHolder(swift::TypeID<Request>::value,
	hash_value(request));
	}
	static bool isEqual(const swift::AnyRequest &lhs,
	const swift::AnyRequest &rhs) {
	return lhs == rhs;
	}
	template <typename Request>
	static bool isEqual(const Request &lhs,
	const swift::AnyRequest &rhs) {
	if (rhs == getEmptyKey() \|\| rhs == getTombstoneKey())
	return false;
	const Request *rhsRequest = rhs.getAs<Request>();
	if (!rhsRequest)
	return false;
	return lhs == *rhsRequest;
	}
	};

	} // end namespace llvm

	#endif // SWIFT_AST_ANYREQUEST_H