Constify several DeclContext parameters. NFC.

Author: jrose-apple

include/swift/AST/ASTContext.h

@@ -522,7 +522,7 @@ class ASTContext {
   ForeignRepresentationInfo
   getForeignRepresentationInfo(NominalTypeDecl *nominal,
                                ForeignLanguage language,
-                               DeclContext *dc);
+                               const DeclContext *dc);
 
   /// Add a declaration to a list of declarations that need to be emitted
   /// as part of the current module or source file, but are otherwise not

include/swift/AST/ProtocolConformance.h

@@ -254,7 +254,7 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance {
 
   /// Determine whether this protocol conformance is visible from the
   /// given declaration context.
-  bool isVisibleFrom(DeclContext *dc) const;
+  bool isVisibleFrom(const DeclContext *dc) const;
 
   /// Determine whether the witness for the given requirement
   /// is either the default definition or was otherwise deduced.

include/swift/AST/Types.h

@@ -712,22 +712,22 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   /// Determine whether the given type is representable in the given
   /// foreign language.
   std::pair<ForeignRepresentableKind, ProtocolConformance *>
-  getForeignRepresentableIn(ForeignLanguage language, DeclContext *dc);
+  getForeignRepresentableIn(ForeignLanguage language, const DeclContext *dc);
 
   /// Determines whether the given Swift type is representable within
   /// the given foreign language.
   ///
   /// A given Swift type is representable in the given foreign
   /// language if the Swift type can be used from source code written
   /// in that language.
-  bool isRepresentableIn(ForeignLanguage language, DeclContext *dc);
+  bool isRepresentableIn(ForeignLanguage language, const DeclContext *dc);
 
   /// Determines whether the type is trivially representable within
   /// the foreign language, meaning that it is both representable in
   /// that language and that the runtime representations are
   /// equivalent.
   bool isTriviallyRepresentableIn(ForeignLanguage language,
-                                  DeclContext *dc);
+                                  const DeclContext *dc);
 
   /// \brief Given that this is a nominal type or bound generic nominal
   /// type, return its parent type; this will be a null type if the type

lib/AST/ASTContext.cpp

@@ -3795,7 +3795,7 @@ static NominalTypeDecl *findUnderlyingTypeInModule(ASTContext &ctx,
 ForeignRepresentationInfo
 ASTContext::getForeignRepresentationInfo(NominalTypeDecl *nominal,
                                          ForeignLanguage language,
-                                         DeclContext *dc) {
+                                         const DeclContext *dc) {
   if (Impl.ForeignRepresentableCache.empty()) {
     // Local function to add a type with the given name and module as
     // trivially-representable.

lib/AST/ProtocolConformance.cpp

@@ -404,7 +404,7 @@ ProtocolConformance::getRootNormalConformance() const {
   return cast<NormalProtocolConformance>(C);
 }
 
-bool ProtocolConformance::isVisibleFrom(DeclContext *dc) const {
+bool ProtocolConformance::isVisibleFrom(const DeclContext *dc) const {
   // FIXME: Implement me!
   return true;
 }

lib/AST/Type.cpp

@@ -1930,8 +1930,8 @@ bool TypeBase::isPotentiallyBridgedValueType() {
 }
 
 /// Determine whether this is a representable Objective-C object type.
-static ForeignRepresentableKind getObjCObjectRepresentable(Type type,
-                                                           DeclContext *dc) {
+static ForeignRepresentableKind
+getObjCObjectRepresentable(Type type, const DeclContext *dc) {
   // @objc metatypes are representable when their instance type is.
   if (auto metatype = type->getAs<AnyMetatypeType>()) {
     // If the instance type is not representable, the metatype is not
@@ -1986,7 +1986,8 @@ static ForeignRepresentableKind getObjCObjectRepresentable(Type type,
 /// to be reflected in PrintAsObjC, so that the Swift type will be
 /// properly printed for (Objective-)C and in SIL's bridging logic.
 static std::pair<ForeignRepresentableKind, ProtocolConformance *>
-getForeignRepresentable(Type type, ForeignLanguage language, DeclContext *dc) {
+getForeignRepresentable(Type type, ForeignLanguage language,
+                        const DeclContext *dc) {
   // Look through one level of optional type, but remember that we did.
   bool wasOptional = false;
   if (auto valueType = type->getAnyOptionalObjectType()) {
@@ -2218,11 +2219,13 @@ getForeignRepresentable(Type type, ForeignLanguage language, DeclContext *dc) {
 }
 
 std::pair<ForeignRepresentableKind, ProtocolConformance *>
-TypeBase::getForeignRepresentableIn(ForeignLanguage language, DeclContext *dc) {
+TypeBase::getForeignRepresentableIn(ForeignLanguage language,
+                                    const DeclContext *dc) {
   return getForeignRepresentable(Type(this), language, dc);
 }
 
-bool TypeBase::isRepresentableIn(ForeignLanguage language, DeclContext *dc) {
+bool TypeBase::isRepresentableIn(ForeignLanguage language,
+                                 const DeclContext *dc) {
   switch (getForeignRepresentableIn(language, dc).first) {
   case ForeignRepresentableKind::None:
     return false;
@@ -2236,7 +2239,7 @@ bool TypeBase::isRepresentableIn(ForeignLanguage language, DeclContext *dc) {
 }
 
 bool TypeBase::isTriviallyRepresentableIn(ForeignLanguage language,
-                                          DeclContext *dc) {
+                                          const DeclContext *dc) {
   switch (getForeignRepresentableIn(language, dc).first) {
   case ForeignRepresentableKind::None:
   case ForeignRepresentableKind::Bridged: