Add ScenicPermission module and AMap CocoaPods with simulator support.

Integrate scenic selection and permission flows into home routing, add AMap SDK for device builds while keeping arm64 simulators compilable via Podfile post_install hooks.

Co-authored-by: Cursor <cursoragent@cursor.com>

Pods/AMapFoundation-NO-IDFA/AMapFoundationKit.framework/AMapReferenceStorage.def

@@ -0,0 +1,197 @@
+//===--- AMapReferenceStorage.def - Non-default reference storage ---*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2018 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 non-default reference storage kind macros used for
+// macro-metaprogramming.
+//
+//===----------------------------------------------------------------------===//
+
+/// There are two fundamental reference storage types: checked and unchecked.
+/// Checked storage types have runtime enforced correctness.
+/// Unchecked storage types have no runtime enforced correctness.
+///
+/// Checked reference storage types are also subcategorized by loadability.
+/// * Always loadable: The compiler may move the reference or use registers.
+/// * Never loadable: The runtime (etc) tracks the address of the reference.
+/// * Sometimes loadable: If the reference is a native object, then it is
+///   always loadable. Otherwise fall back to never loadable semantics, a.k.a.
+///   "address only".
+///
+/// Unchecked reference storage types are always loadable.
+///
+/// The primary macros therefore are:
+/// * ALWAYS_LOADABLE_CHECKED_REF_STORAGE
+/// * SOMETIMES_LOADABLE_CHECKED_REF_STORAGE
+/// * NEVER_LOADABLE_CHECKED_REF_STORAGE
+/// * UNCHECKED_REF_STORAGE
+///
+/// Helper macros include:
+/// * CHECKED_REF_STORAGE -- Any checked reference storage type. Specifically
+///   "always", "sometimes", and "never" -- but not "unchecked".
+/// * LOADABLE_REF_STORAGE -- Any loadable reference storage type. Specifically
+///   "always", "sometimes", and "unchecked" -- but not "never".
+/// * ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE -- self describing.
+/// * NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE -- self describing.
+///
+/// SUBSYSTEMS NOTES
+///
+/// In general, reference storage types are barely visible in the user facing
+/// type system and therefore AST clients above SIL can get away with
+/// just REF_STORAGE, or CHECKED_REF_STORAGE with UNCHECKED_REF_STORAGE.
+///
+/// When it comes to SIL aware AST clients, loadability matters. The best way
+/// to understand how the helper macros are used is to look at SILNodes.def.
+/// What follows is a short -- possibly not up to date -- summary:
+///
+/// UNCHECKED_REF_STORAGE
+///   Name##RetainValueInst
+///   Name##ReleaseValueInst
+/// LOADABLE_REF_STORAGE
+///   Ref*ToNameInst
+///   Name*ToRefInst
+/// NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE
+///   Load##Name##Inst
+///   Store##Name##Inst
+/// ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE
+///   Copy##Name##ValueInst
+///   StrongRetain##Name##Inst
+///   Name##RetainInst
+///   Name##ReleaseInst
+///
+/// After helper macro expansion:
+///
+/// UNCHECKED_REF_STORAGE
+///   Ref*ToNameInst
+///   Name*ToRefInst
+///   Name##RetainValueInst
+///   Name##ReleaseValueInst
+/// ALWAYS_LOADABLE_CHECKED_REF_STORAGE
+///   Ref*ToNameInst
+///   Name*ToRefInst
+///   Copy##Name##ValueInst
+///   StrongRetain##Name##Inst
+///   Name##RetainInst
+///   Name##ReleaseInst
+/// SOMETIMES_LOADABLE_CHECKED_REF_STORAGE
+///   Ref*ToNameInst
+///   Name*ToRefInst
+///   Load##Name##Inst
+///   Store##Name##Inst
+///   Copy##Name##ValueInst
+///   StrongRetain##Name##Inst
+///   Name##RetainInst
+///   Name##ReleaseInst
+/// NEVER_LOADABLE_CHECKED_REF_STORAGE
+///   Load##Name##Inst
+///   Store##Name##Inst
+///
+/// Finally, a note about IRGen: TypeInfos need to be created per reference
+/// storage type, and SOMETIMES_LOADABLE_CHECKED_REF_STORAGE needs *two*
+/// TypeInfos to be created. One for the loadable scenario, and one for the
+/// address-only scenario.
+
+
+#ifndef REF_STORAGE
+#define REF_STORAGE(Name, name, NAME)
+#endif
+
+#ifdef ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE
+#if defined(ALWAYS_LOADABLE_CHECKED_REF_STORAGE) || \
+defined(SOMETIMES_LOADABLE_CHECKED_REF_STORAGE)
+#error Overlapping meta-programming macros
+#endif
+#define ALWAYS_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME) \
+ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME)
+#define SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME) \
+ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME)
+#endif
+
+#ifdef NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE
+#if defined(NEVER_LOADABLE_CHECKED_REF_STORAGE) || \
+defined(SOMETIMES_LOADABLE_CHECKED_REF_STORAGE)
+#error Overlapping meta-programming macros
+#endif
+#define NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME) \
+NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME)
+#define SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME) \
+NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME)
+#endif
+
+#ifdef LOADABLE_REF_STORAGE
+#if defined(ALWAYS_LOADABLE_CHECKED_REF_STORAGE) || \
+defined(SOMETIMES_LOADABLE_CHECKED_REF_STORAGE) || \
+defined(UNCHECKED_REF_STORAGE)
+#error Overlapping meta-programming macros
+#endif
+#define ALWAYS_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME) \
+LOADABLE_REF_STORAGE(Name, name, NAME)
+#define SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME) \
+LOADABLE_REF_STORAGE(Name, name, NAME)
+#define UNCHECKED_REF_STORAGE(Name, name, NAME) \
+LOADABLE_REF_STORAGE(Name, name, NAME)
+#endif
+
+#ifdef CHECKED_REF_STORAGE
+#if defined(SOMETIMES_LOADABLE_CHECKED_REF_STORAGE) || \
+defined(ALWAYS_LOADABLE_CHECKED_REF_STORAGE) || \
+defined(NEVER_LOADABLE_CHECKED_REF_STORAGE)
+#error Overlapping meta-programming macros
+#endif
+#define ALWAYS_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME) \
+CHECKED_REF_STORAGE(Name, name, NAME)
+#define SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME) \
+CHECKED_REF_STORAGE(Name, name, NAME)
+#define NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME) \
+CHECKED_REF_STORAGE(Name, name, NAME)
+#endif
+
+#ifndef NEVER_LOADABLE_CHECKED_REF_STORAGE
+#define NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME) \
+REF_STORAGE(Name, name, NAME)
+#endif
+
+#ifndef SOMETIMES_LOADABLE_CHECKED_REF_STORAGE
+#define SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME) \
+REF_STORAGE(Name, name, NAME)
+#endif
+
+#ifndef ALWAYS_LOADABLE_CHECKED_REF_STORAGE
+#define ALWAYS_LOADABLE_CHECKED_REF_STORAGE(Name, name, NAME) \
+REF_STORAGE(Name, name, NAME)
+#endif
+
+#ifndef UNCHECKED_REF_STORAGE
+#define UNCHECKED_REF_STORAGE(Name, name, NAME) \
+REF_STORAGE(Name, name, NAME)
+#endif
+
+#ifndef REF_STORAGE_RANGE
+#define REF_STORAGE_RANGE(First, Last)
+#endif
+
+// NOTE: You will need to update ReferenceOwnership in ModuleFormat.h.
+//NEVER_LOADABLE_CHECKED_REF_STORAGE(Weak, weak, WEAK)
+//SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Unowned, unowned, UNOWNED)
+//UNCHECKED_REF_STORAGE(Unmanaged, unmanaged, UNMANAGED)
+REF_STORAGE_RANGE(Weak, Unmanaged)
+
+#undef REF_STORAGE
+#undef NEVER_LOADABLE_CHECKED_REF_STORAGE
+#undef ALWAYS_LOADABLE_CHECKED_REF_STORAGE
+#undef SOMETIMES_LOADABLE_CHECKED_REF_STORAGE
+#undef UNCHECKED_REF_STORAGE
+#undef REF_STORAGE_RANGE
+
+#undef ALWAYS_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE
+#undef NEVER_OR_SOMETIMES_LOADABLE_CHECKED_REF_STORAGE
+#undef LOADABLE_REF_STORAGE
+#undef CHECKED_REF_STORAGE