//===--- StandardTypesMangling.def - Mangling Metaprogramming ---*- 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
//
//===----------------------------------------------------------------------===//

/// STANDARD_TYPE(KIND, MANGLING, TYPENAME)
///   The 1-character MANGLING for a known TYPENAME of KIND.
///
/// STANDARD_TYPE_CONCURRENCY(KIND, MANGLING, TYPENAME)
///   The 1-character MANGLING for a known TYPENAME of KIND that is in the
///   second level of standard types in the Concurrency model, all of which are
///   mangled with the form Sc<MANGLING>.
///
/// OBJC_INTEROP_STANDARD_TYPE(KIND, MANGLING, TYPENAME)
///   The 1-character MANGLING for a known TYPENAME of KIND, for a type that's
///   only available with ObjC interop enabled.

#ifndef OBJC_INTEROP_STANDARD_TYPE
#define OBJC_INTEROP_STANDARD_TYPE(KIND, MANGLING, TYPENAME) \
  STANDARD_TYPE(KIND, MANGLING, TYPENAME)
#endif


OBJC_INTEROP_STANDARD_TYPE(Structure, A, AutoreleasingUnsafeMutablePointer)
STANDARD_TYPE(Structure, a, Array)
STANDARD_TYPE(Structure, b, Bool)
STANDARD_TYPE(Structure, D, Dictionary)
STANDARD_TYPE(Structure, d, Double)
STANDARD_TYPE(Structure, f, Float)
STANDARD_TYPE(Structure, h, Set)
STANDARD_TYPE(Structure, I, DefaultIndices)
STANDARD_TYPE(Structure, i, Int)
STANDARD_TYPE(Structure, J, Character)
STANDARD_TYPE(Structure, N, ClosedRange)
STANDARD_TYPE(Structure, n, Range)
STANDARD_TYPE(Structure, O, ObjectIdentifier)
STANDARD_TYPE(Structure, P, UnsafePointer)
STANDARD_TYPE(Structure, p, UnsafeMutablePointer)
STANDARD_TYPE(Structure, R, UnsafeBufferPointer)
STANDARD_TYPE(Structure, r, UnsafeMutableBufferPointer)
STANDARD_TYPE(Structure, S, String)
STANDARD_TYPE(Structure, s, Substring)
STANDARD_TYPE(Structure, u, UInt)
STANDARD_TYPE(Structure, V, UnsafeRawPointer)
STANDARD_TYPE(Structure, v, UnsafeMutableRawPointer)
STANDARD_TYPE(Structure, W, UnsafeRawBufferPointer)
STANDARD_TYPE(Structure, w, UnsafeMutableRawBufferPointer)

STANDARD_TYPE(Enum, q, Optional)

STANDARD_TYPE(Protocol, B, BinaryFloatingPoint)
STANDARD_TYPE(Protocol, E, Encodable)
STANDARD_TYPE(Protocol, e, Decodable)
STANDARD_TYPE(Protocol, F, FloatingPoint)
STANDARD_TYPE(Protocol, G, RandomNumberGenerator)
STANDARD_TYPE(Protocol, H, Hashable)
STANDARD_TYPE(Protocol, j, Numeric)
STANDARD_TYPE(Protocol, K, BidirectionalCollection)
STANDARD_TYPE(Protocol, k, RandomAccessCollection)
STANDARD_TYPE(Protocol, L, Comparable)
STANDARD_TYPE(Protocol, l, Collection)
STANDARD_TYPE(Protocol, M, MutableCollection)
STANDARD_TYPE(Protocol, m, RangeReplaceableCollection)
STANDARD_TYPE(Protocol, Q, Equatable)
STANDARD_TYPE(Protocol, T, Sequence)
STANDARD_TYPE(Protocol, t, IteratorProtocol)
STANDARD_TYPE(Protocol, U, UnsignedInteger)
STANDARD_TYPE(Protocol, X, RangeExpression)
STANDARD_TYPE(Protocol, x, Strideable)
STANDARD_TYPE(Protocol, Y, RawRepresentable)
STANDARD_TYPE(Protocol, y, StringProtocol)
STANDARD_TYPE(Protocol, Z, SignedInteger)
STANDARD_TYPE(Protocol, z, BinaryInteger)

STANDARD_TYPE_CONCURRENCY(Protocol, A, Actor)
STANDARD_TYPE_CONCURRENCY(Structure, C, CheckedContinuation)
STANDARD_TYPE_CONCURRENCY(Structure, c, UnsafeContinuation)
STANDARD_TYPE_CONCURRENCY(Structure, E, CancellationError)
STANDARD_TYPE_CONCURRENCY(Structure, e, UnownedSerialExecutor)
STANDARD_TYPE_CONCURRENCY(Protocol, F, Executor)
STANDARD_TYPE_CONCURRENCY(Protocol, f, SerialExecutor)
STANDARD_TYPE_CONCURRENCY(Structure, G, TaskGroup)
STANDARD_TYPE_CONCURRENCY(Structure, g, ThrowingTaskGroup)
STANDARD_TYPE_CONCURRENCY(Protocol, h, TaskExecutor)
STANDARD_TYPE_CONCURRENCY(Protocol, I, AsyncIteratorProtocol)
STANDARD_TYPE_CONCURRENCY(Protocol, i, AsyncSequence)
STANDARD_TYPE_CONCURRENCY(Structure, J, UnownedJob)
STANDARD_TYPE_CONCURRENCY(Class, M, MainActor)
STANDARD_TYPE_CONCURRENCY(Structure, P, TaskPriority)
STANDARD_TYPE_CONCURRENCY(Structure, S, AsyncStream)
STANDARD_TYPE_CONCURRENCY(Structure, s, AsyncThrowingStream)
STANDARD_TYPE_CONCURRENCY(Structure, T, Task)
STANDARD_TYPE_CONCURRENCY(Structure, t, UnsafeCurrentTask)

#undef STANDARD_TYPE
#undef OBJC_INTEROP_STANDARD_TYPE
#undef STANDARD_TYPE_CONCURRENCY
