[C++20][Modules] Handle diagnosing TU-local exposures [P1815].

[iains]

Summary

This implements P1815R2: Translation-unit-local entities

• cases in a function bodies
• initializers for variables
• decltype() for variables
• decltype() for function return values
• auto for variables
• constexpt/consteval for function and variable types
• support for function templates
• support for template instantiations in module consumers
• initial support for lambdas.
• support handing lambda exposures.

[iains]

added @ChuanqiXu as requested (this is a draft, it does not need review at this time).

[iains]

rebased, added support for decltype and constexpr/constal and auto.

[iains]

rebased, reworked handling of constexpr variables.

[iains]

rebased, added support for function templates.

[iains]

rebased, added support for template instantiations.

depends on lookup changes for proper functionality,

[iains]

reapply onto parent revision

[iains]

rebased and moved some lookup stuff to D145965.

added initial support for lambda closure cases.

[iains]

rebased and adjusted to upstream changes

[iains]

rebased - added support for lambda expression exposures.

[iains]

rebased, fixed some formatting

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_ovl_static_nonstatic_member : Error<
   "static and non-static member functions with the same parameter types "
   "cannot be overloaded">;
 
 let Deferrable = 1 in {
 
 def err_ovl_no_viable_function_in_call : Error<
   "no matching function for call to %0">;
+def err_ovl_exposure_function_in_call : Error<
+  "the overload set for the call to %0 contains one or more exposures">;
 def err_ovl_no_viable_member_function_in_call : Error<
   "no matching member function for call to %0">;
 def err_ovl_ambiguous_call : Error<
   "call to %0 is ambiguous">;
 def err_ovl_deleted_call : Error<"call to deleted function %0">;
 def err_ovl_ambiguous_member_call : Error<
   "call to member function %0 is ambiguous">;
 def err_ovl_deleted_member_call : Error<
def note_ovl_candidate_substitution_failure : Note<
     "candidate template ignored: substitution failure%0%1">;
 def note_ovl_candidate_disabled_by_enable_if : Note<
     "candidate template ignored: disabled by %0%1">;
 def note_ovl_candidate_disabled_by_requirement : Note<
     "candidate template ignored: requirement '%0' was not satisfied%1">;
 def note_ovl_candidate_has_pass_object_size_params: Note<
     "candidate address cannot be taken because parameter %0 has "
     "pass_object_size attribute">;
+def note_ovl_candidate_is_exposure: Note<"candidate %0 is an exposure">;
 def err_diagnose_if_succeeded : Error<"%0">;
 def warn_diagnose_if_succeeded : Warning<"%0">, InGroup<UserDefinedWarnings>,
     ShowInSystemHeader;
 def note_ovl_candidate_disabled_by_function_cond_attr : Note<
     "candidate disabled: %0">;
 def err_addrof_function_disabled_by_enable_if_attr : Error<
     "cannot take address of function %0 because it has one or more "
     "non-tautological enable_if conditions">;
def note_implicit_member_target_infer_collision : Note<
     "%select{__device__|__global__|__host__|__host__ __device__}1 and "
     "%select{__device__|__global__|__host__|__host__ __device__}2 members">;
 
 def note_ambiguous_type_conversion: Note<
     "because of ambiguity in conversion %diff{of $ to $|between types}0,1">;
 def note_ovl_builtin_candidate : Note<"built-in candidate %0">;
 def err_ovl_no_viable_function_in_init : Error<
   "no matching constructor for initialization of %0">;
+def err_ovl_conversion_has_exposure : Error<
+  "the overload set for conversion from %1 to %2 contains an exposure">;
 def err_ovl_no_conversion_in_cast : Error<
   "cannot convert %1 to %2 without a conversion operator">;
 def err_ovl_no_viable_conversion_in_cast : Error<
   "no matching conversion for %select{|static_cast|reinterpret_cast|"
   "dynamic_cast|C-style cast|functional-style cast|}0 from %1 to %2">;
 def err_ovl_ambiguous_conversion_in_cast : Error<
   "ambiguous conversion for %select{|static_cast|reinterpret_cast|"
   "dynamic_cast|C-style cast|functional-style cast|}0 from %1 to %2">;
def err_ovl_no_oper :
     Error<"type %0 does not provide a %select{subscript|call}1 operator">;
 def err_ovl_unresolvable : Error<
   "reference to %select{overloaded|multiversioned}1 function could not be "
   "resolved; did you mean to call it%select{| with no arguments}0?">;
 def err_bound_member_function : Error<
   "reference to non-static member function must be called"
   "%select{|; did you mean to call it with no arguments?}0">;
 def note_possible_target_of_call : Note<"possible target for call">;
+def err_ovl_destructor_has_exposure : Error<
+  "the overload set for class %0 destructor contains an exposure">;
 def err_no_viable_destructor : Error<
   "no viable destructor found for class %0">;
 def err_ambiguous_destructor : Error<
   "destructor of class %0 is ambiguous">;
 
 def err_ovl_no_viable_object_call : Error<
   "no matching function for call to object of type %0">;
 def err_ovl_ambiguous_object_call : Error<
def note_defaulted_comparison_inaccessible : Note<
   " member of %6 to compare member %2| to compare base class %2}1">;
 def note_defaulted_comparison_calls_deleted : Note<
   "defaulted %0 is implicitly deleted because it would invoke a deleted "
   "comparison function%select{| for member %2| for base class %2}1">;
 def note_defaulted_comparison_no_viable_function : Note<
   "defaulted %0 is implicitly deleted because there is no viable "
   "%select{three-way comparison function|'operator=='}1 for "
   "%select{|member |base class }2%3">;
+def err_ovl_defaulted_comparison_exposure : Error<"the overload set for "
+  "%select{three-way comparison function|'operator=='}1 for "
+  "%select{|member |base class }2%3 contains an exposure">;
 def note_defaulted_comparison_no_viable_function_synthesized : Note<
   "three-way comparison cannot be synthesized because there is no viable "
   "function for %select{'=='|'<'}0 comparison">;
 def note_defaulted_comparison_not_rewritten_callee : Note<
   "defaulted %0 is implicitly deleted because this non-rewritten comparison "
   "function would be the best match for the comparison">;
 def note_defaulted_comparison_not_rewritten_conversion : Note<
   "defaulted %0 is implicitly deleted because a builtin comparison function "
def ext_equivalent_internal_linkage_decl_in_modules : ExtWarn<
   InGroup<DiagGroup<"modules-ambiguous-internal-linkage">>;
 def note_equivalent_internal_linkage_decl : Note<
   "declared here%select{ in module '%1'|}0">;
 
 def note_redefinition_modules_same_file : Note<
   "'%0' included multiple times, additional include site in header from module '%1'">;
 def note_redefinition_include_same_file : Note<
   "'%0' included multiple times, additional include site here">;
+
+def err_use_is_exposure : Error<"use of TU-local entity %0 is an exposure">;
+
 }
 
 let CategoryName = "Coroutines Issue" in {
 def err_return_in_coroutine : Error<
   "return statement not allowed in coroutine; did you mean 'co_return'?">;
 def note_declared_coroutine_here : Note<
   "function is a coroutine due to use of '%0' here">;
 def err_coroutine_objc_method : Error<

clang/include/clang/Sema/Overload.h

enum OverloadingResult {
 
     /// No viable function found.
     OR_No_Viable_Function,
 
     /// Ambiguous candidates found.
     OR_Ambiguous,
 
     /// Succeeded, but refers to a deleted function.
-    OR_Deleted
+    OR_Deleted,
+
+    /// At least one candidate is an exposure.
+    OR_Exposure
   };
 
   enum OverloadCandidateDisplayKind {
     /// Requests that all candidates be shown.  Viable candidates will
     /// be printed first.
     OCD_AllCandidates,
 
     /// Requests that only viable candidates be shown.
     OCD_ViableCandidates,
 
     /// Requests that only tied-for-best candidates be shown.
-    OCD_AmbiguousCandidates
+    OCD_AmbiguousCandidates,
+
+    /// Requests that only candidates that are exposures  be shown.
+    OCD_ExposureCandidates
   };
 
   /// The parameter ordering that will be used for the candidate. This is
   /// used to represent C++20 binary operator rewrites that reverse the order
   /// of the arguments. If the parameter ordering is Reversed, the Args list is
   /// reversed (but obviously the ParamDecls for the function are not).
   ///
   /// After forming an OverloadCandidate with reversed parameters, the list
enum OverloadFailureKind {
     /// mismatch between the object being constructed and the overload
     /// candidate.
     ovl_fail_object_addrspace_mismatch,
 
     /// This candidate was not viable because its associated constraints were
     /// not satisfied.
     ovl_fail_constraints_not_satisfied,
 
-    /// This candidate was not viable because it has internal linkage and is
-    /// from a different module unit than the use.
+    /// This candidate was not viable because it has module linkage and is
+    /// from a different module than the use.
     ovl_fail_module_mismatched,
+
+    /// This candidate was not viable because it has internal linkage and is
+    /// is an exposure of a declaration in a different TU of this module.
+    ovl_fail_module_exposure,
   };
 
   /// A list of implicit conversion sequences for the arguments of an
   /// OverloadCandidate.
   using ConversionSequenceList =
       llvm::MutableArrayRef<ImplicitConversionSequence>;
 
   /// OverloadCandidate - A single candidate in an overload set (C++ 13.3).

clang/include/clang/Sema/Sema.h

private:
   /// Cache for module units which is usable for current module.
   llvm::DenseSet<const Module *> UsableModuleUnitsCache;
 
   bool isUsableModule(const Module *M);
 
   bool isAcceptableSlow(const NamedDecl *D, AcceptableKind Kind);
 
 public:
+  /// Determine of a Decl is TU-local.
+  bool isTULocal(const NamedDecl *ND) const {
+    if (ND->getFormalLinkage() == Linkage::InternalLinkage) {
+#ifdef PRE_P2788R0
+      if (auto *VD = dyn_cast<VarDecl>(ND)) {
+        QualType VT = VD->getType();
+        if (!VT.isConstQualified() || VT.isVolatileQualified())
+          return true;
+        if (VD->hasConstantInitialization())
+          return false; // non-volatile, const with const init.
+      }
+#endif
+      return true;
+    }
+    return false;
+  }
+
+  bool isTULocal(const Decl *D) const {
+    if (auto *ND = dyn_cast<NamedDecl>(D))
+      return isTULocal(ND);
+    return true;
+  }
+
+  /// Diagnose cases where use of a TU-local entity in a function body is an
+  /// 'exposure'.
+  bool diagnoseFunctionBodyExposures(const NamedDecl *D, SourceLocation Loc);
+
+  /// Diagnose cases where use of a TU-local entity in a variable initializer is
+  /// an 'exposure'.
+  bool diagnoseVarInitExposures(const VarDecl *VDecl, const Expr *Init,
+                                bool OnlyLambdaExpr);
+
+  /// Diagnose 'exposure's in an expression.
+  bool diagnoseExprExposure(const Expr *E);
+
+  /// Diagnose 'exposure's in a function instantiation.
+  bool diagnoseInstantiationExposure(const FunctionDecl *F, SourceLocation L);
+
   /// Get the module unit whose scope we are currently within.
   Module *getCurrentModule() const {
     return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
   }
 
   /// Is the module scope we are an interface?
   bool currentModuleIsInterface() const {
     return ModuleScopes.empty() ? false : ModuleScopes.back().ModuleInterface;

clang/lib/Sema/SemaCast.cpp

case OR_Ambiguous:
     msg = diag::err_ovl_ambiguous_conversion_in_cast;
     howManyCandidates = OCD_AmbiguousCandidates;
     break;
 
   case OR_Deleted:
     msg = diag::err_ovl_deleted_conversion_in_cast;
     howManyCandidates = OCD_ViableCandidates;
     break;
+  case OR_Exposure:
+    msg = diag::err_ovl_conversion_has_exposure;
+    howManyCandidates = OCD_ExposureCandidates;
+    break;
   }
 
   candidates.NoteCandidates(
       PartialDiagnosticAt(range.getBegin(),
                           S.PDiag(msg) << CT << srcType << destType << range
                                        << src->getSourceRange()),
       S, howManyCandidates, src);
 

clang/lib/Sema/SemaDecl.cpp

if (!Builtin::evaluateRequiredTargetFeatures(
       Diag(NewVD->getLocation(), diag::err_sve_vector_in_non_sve_target) << T;
       NewVD->setInvalidDecl();
       return;
     }
   }
 
   if (T->isRVVType())
     checkRVVTypeSupport(T, NewVD->getLocation(), cast<ValueDecl>(CurContext));
+
+  // C++ [basic.link]/14 check exposures where the type of a variable is
+  // specified by a decltype().
+  if (getLangOpts().CPlusPlusModules && isCurrentModulePurview() &&
+      NewVD->getFormalLinkage() >= Linkage::ModuleLinkage) {
+    QualType Ty = T;
+    while (Ty->isPointerType() || Ty->isReferenceType())
+      Ty = Ty->getPointeeType();
+    if (Ty->isDecltypeType()) {
+      const Expr *E = Ty->getAs<DecltypeType>()->getUnderlyingExpr();
+      if (diagnoseExprExposure(E)) {
+        NewVD->setInvalidDecl();
+        return;
+      }
+    }
+  }
 }
 
 /// Perform semantic checking on a newly-created variable
 /// declaration.
 ///
 /// This routine performs all of the type-checking required for a
 /// variable declaration once it has been built. It is used both to
 /// check variables after they have been parsed and their declarators
bool Sema::DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
   // If this is a redeclaration, check that the type we just deduced matches
   // the previously declared type.
   if (VarDecl *Old = VDecl->getPreviousDecl()) {
     // We never need to merge the type, because we cannot form an incomplete
     // array of auto, nor deduce such a type.
     MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/ false);
   }
 
+  // C++ [basic.link]/14 check exposures in the type deduced for a variable.
+  // We cannot check this in CheckVariableDeclarationType() since auto-ness is
+  // discarded above.
+  if (getLangOpts().CPlusPlusModules && !VDecl->isInvalidDecl() &&
+      isCurrentModulePurview() &&
+      (((VDecl->isInline() || VDecl->isConstexpr() ||
+         (VDecl->getType()->getAsCXXRecordDecl() &&
+          VDecl->getType()->getAsCXXRecordDecl()->isLambda())) &&
+        VDecl->getFormalLinkage() >= Linkage::ModuleLinkage) ||
+       (VDecl->isConstexpr() && VDecl->getStorageClass() != SC_Static))) {
+    const Expr *E = Init;
+    if (auto *DRE = dyn_cast<DeclRefExpr>(Init)) {
+      // look through references.
+      if (auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
+          if (VD->getType()->isReferenceType()) {
+            assert(VD->hasInit());
+            E = VD->getInit();
+          }
+      }
+    }
+    if (E && diagnoseVarInitExposures(VDecl, E, false))
+      VDecl->setInvalidDecl();
+  }
+
   // Check the deduced type is valid for a variable declaration.
   CheckVariableDeclarationType(VDecl);
   return VDecl->isInvalidDecl();
 }
 
 void Sema::checkNonTrivialCUnionInInitializer(const Expr *Init,
                                               SourceLocation Loc) {
   if (auto *EWC = dyn_cast<ExprWithCleanups>(Init))
if (getLangOpts().CPlusPlus) {
 
     if (VDecl->hasLocalStorage())
       setFunctionHasBranchProtectedScope();
 
     if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) {
       VDecl->setInvalidDecl();
       return;
     }
+
+    // C++ [basic.link]/14 : handle exposures in variable initializers.
+    // A declaration is an exposure if it either names a TU-local entity
+    // ...
+    // or defines a constexpr variable initialized to a TU-local value.
+    if (getLangOpts().CPlusPlusModules && isCurrentModulePurview()) {
+      if ((((VDecl->isInline() || VDecl->isConstexpr()) &&
+          VDecl->getFormalLinkage() >= Linkage::ModuleLinkage) ||
+         (VDecl->isConstexpr() && VDecl->getStorageClass() != SC_Static)) &&
+        diagnoseVarInitExposures(VDecl, Init, /*OnlyLambdaExpr*/false)) {
+        VDecl->setInvalidDecl();
+        return;
+      } else if (VDecl->getFormalLinkage() >= Linkage::ModuleLinkage &&
+                 !VDecl->isTemplated() &&
+                 diagnoseVarInitExposures(VDecl, Init, /*OnlyLambdaExpr*/true)) {
+        VDecl->setInvalidDecl();
+        return;
+      }
+    }
   }
 
   // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside
   // a kernel function cannot be initialized."
   if (VDecl->getType().getAddressSpace() == LangAS::opencl_local) {
     Diag(VDecl->getLocation(), diag::err_local_cant_init);
     VDecl->setInvalidDecl();
     return;
if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
       !FD->isInvalidDecl() && BodyKind != FnBodyKind::Delete &&
       (RequireCompleteType(FD->getLocation(), ResultType,
                            diag::err_func_def_incomplete_result) ||
        RequireNonAbstractType(FD->getLocation(), FD->getReturnType(),
                               diag::err_abstract_type_in_decl,
                               AbstractReturnType)))
     FD->setInvalidDecl();
 
+  // C++ [basic.link]/14 : Diagnose exposure of TU-local entities in function
+  // return types specified with decltype().
+  if (getLangOpts().CPlusPlusModules && !FD->isInvalidDecl() &&
+      !FD->isStatic() && isCurrentModulePurview() &&
+      ResultType->isDecltypeType()) {
+    const Expr *E = ResultType->getAs<DecltypeType>()->getUnderlyingExpr();
+    if (diagnoseExprExposure(E))
+      FD->setInvalidDecl();
+  }
+
   if (FnBodyScope)
     PushDeclContext(FnBodyScope, FD);
 
   // Check the validity of our function parameters
   if (BodyKind != FnBodyKind::Delete)
     CheckParmsForFunctionDef(FD->parameters(),
                              /*CheckParameterNames=*/true);
 
case OR_Deleted:
     Record->addedSelectedDestructor(dyn_cast<CXXDestructorDecl>(Best->Function));
     break;
 
   case OR_Ambiguous:
     Msg = diag::err_ambiguous_destructor;
     DisplayKind = OCD_AmbiguousCandidates;
     break;
 
+  case OR_Exposure:
+    Msg = diag::err_ovl_destructor_has_exposure;
+    DisplayKind = OCD_ExposureCandidates;
+    break;
+
   case OR_No_Viable_Function:
     Msg = diag::err_no_viable_destructor;
     DisplayKind = OCD_AllCandidates;
     break;
   }
 
   if (Msg) {
     // OpenCL have got their own thing going with destructors. It's slightly broken,

clang/lib/Sema/SemaDeclCXX.cpp

case OR_Deleted:
                  diag::note_defaulted_comparison_calls_deleted)
               << FD << Subobj.Kind << Subobj.Decl;
           S.NoteDeletedFunction(Best->Function);
         }
       }
       R = Result::deleted();
       break;
 
+    case OR_Exposure:
+      S.Diag(Subobj.Loc, diag::err_ovl_defaulted_comparison_exposure)
+            << (OO == OO_ExclaimEqual) << Subobj.Kind << Subobj.Decl;
+      CandidateSet.NoteCandidates(S, Args,
+        CandidateSet.CompleteCandidates(S, OCD_ExposureCandidates, Args,
+                                        FD->getLocation()));
+      break;
     case OR_No_Viable_Function:
       // If there's no usable candidate, we're done unless we can rewrite a
       // '<=>' in terms of '==' and '<'.
       if (OO == OO_Spaceship &&
           S.Context.CompCategories.lookupInfoForType(FD->getReturnType())) {
         // For any kind of comparison category return type, we need a usable
         // '==' and a usable '<'.
         if (!R.add(visitBinaryOperator(OO_EqualEqual, Args, Subobj,

clang/lib/Sema/SemaExpr.cpp

 /// This is only a warning because we used to silently accept this code, but
 /// in many cases it will not behave correctly. This is not enabled in C++ mode
 /// because the restriction language is a bit weaker (C++11 [basic.def.odr]p6)
 /// and so while there may still be user mistakes, most of the time we can't
 /// prove that there are errors.
 static void diagnoseUseOfInternalDeclInInlineFunction(Sema &S,
                                                       const NamedDecl *D,
                                                       SourceLocation Loc) {
-  // This is disabled under C++; there are too many ways for this to fire in
-  // contexts where the warning is a false positive, or where it is technically
-  // correct but benign.
-  if (S.getLangOpts().CPlusPlus)
-    return;
 
   // Check if this is an inlined function or method.
   FunctionDecl *Current = S.getCurFunctionDecl();
   if (!Current)
     return;
+
+  // As noted above, this test should not be applied to C++.
+  assert(!S.getLangOpts().CPlusPlus);
+
   if (!Current->isInlined())
     return;
   if (!Current->isExternallyVisible())
     return;
 
   // Check if the decl has internal linkage.
   if (D->getFormalLinkage() != InternalLinkage)
     return;
if (const auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(D)) {
     return true;
   }
 
   DiagnoseAvailabilityOfDecl(D, Locs, UnknownObjCClass, ObjCPropertyAccess,
                              AvoidPartialAvailabilityChecks, ClassReceiver);
 
   DiagnoseUnusedOfDecl(*this, D, Loc);
 
+  if (getLangOpts().CPlusPlus) {
+    // C++ [basic.link]/14 : handle exposures in function bodies.
+    if (getLangOpts().CPlusPlusModules && diagnoseFunctionBodyExposures(D, Loc))
+      return true;
+  } else
     diagnoseUseOfInternalDeclInInlineFunction(*this, D, Loc);
 
   if (D->hasAttr<AvailableOnlyInDefaultEvalMethodAttr>()) {
     if (getLangOpts().getFPEvalMethod() !=
             LangOptions::FPEvalMethodKind::FEM_UnsetOnCommandLine &&
         PP.getLastFPEvalPragmaLocation().isValid() &&
         PP.getCurrentFPEvalMethod() != getLangOpts().getFPEvalMethod())
       Diag(D->getLocation(),
            diag::err_type_available_only_in_default_eval_method)

clang/lib/Sema/SemaExprCXX.cpp

case OR_Success: {
     if (S.CheckAllocationAccess(R.getNameLoc(), Range, R.getNamingClass(),
                                 Best->FoundDecl) == Sema::AR_inaccessible)
       return true;
 
     Operator = FnDecl;
     return false;
   }
 
+  case OR_Exposure:
   case OR_No_Viable_Function:
     // C++17 [expr.new]p13:
     //   If no matching function is found and the allocated object type has
     //   new-extended alignment, the alignment argument is removed from the
     //   argument list, and overload resolution is performed again.
     if (PassAlignment) {
       PassAlignment = false;
       AlignArg = Args[1];
if (!FnDecl->isReplaceableGlobalAllocationFunction()) {
           << R.getLookupName() << FnDecl->getSourceRange();
       return true;
     }
 
     Operator = FnDecl;
     return false;
   }
 
+  case OR_Exposure:
   case OR_No_Viable_Function:
     Candidates.NoteCandidates(
         PartialDiagnosticAt(R.getNameLoc(),
                             S.PDiag(diag::err_ovl_no_viable_function_in_call)
                                 << R.getLookupName() << Range),
         S, OCD_AllCandidates, Args);
     return true;
 
case OR_Success: {
       if (RHSRes.isInvalid())
         break;
       RHS = RHSRes;
       if (Best->Function)
         Self.MarkFunctionReferenced(QuestionLoc, Best->Function);
       return false;
     }
 
+    case OR_Exposure:
     case OR_No_Viable_Function:
 
       // Emit a better diagnostic if one of the expressions is a null pointer
       // constant and the other is a pointer type. In this case, the user most
       // likely forgot to take the address of the other expression.
       if (Self.DiagnoseConditionalForNull(LHS.get(), RHS.get(), QuestionLoc))
         return true;
 

clang/lib/Sema/SemaInit.cpp

static ExprResult CopyObject(Sema &S,
   switch (ResolveConstructorOverload(
       S, Loc, CurInitExpr, CandidateSet, T, Ctors, Best,
       /*CopyInitializing=*/false, /*AllowExplicit=*/true,
       /*OnlyListConstructors=*/false, /*IsListInit=*/false,
       /*SecondStepOfCopyInit=*/true)) {
   case OR_Success:
     break;
 
+  case OR_Exposure:
   case OR_No_Viable_Function:
     CandidateSet.NoteCandidates(
         PartialDiagnosticAt(
             Loc, S.PDiag(IsExtraneousCopy && !S.isSFINAEContext()
                              ? diag::ext_rvalue_to_reference_temp_copy_no_viable
                              : diag::err_temp_copy_no_viable)
                      << (int)Entity.getKind() << CurInitExpr->getType()
                      << CurInitExpr->getSourceRange()),
static void CheckCXX98CompatAccessibleCopy(Sema &S,
 
   switch (OR) {
   case OR_Success:
     S.CheckConstructorAccess(Loc, cast<CXXConstructorDecl>(Best->Function),
                              Best->FoundDecl, Entity, Diag);
     // FIXME: Check default arguments as far as that's possible.
     break;
 
+  case OR_Exposure:
   case OR_No_Viable_Function:
     CandidateSet.NoteCandidates(PartialDiagnosticAt(Loc, Diag), S,
                                 OCD_AllCandidates, CurInitExpr);
     break;
 
   case OR_Ambiguous:
     CandidateSet.NoteCandidates(PartialDiagnosticAt(Loc, Diag), S,
                                 OCD_AmbiguousCandidates, CurInitExpr);
case OR_Ambiguous:
                      << OnlyArg->getType() << DestType
                      << Args[0]->getSourceRange())
                   : (S.PDiag(diag::err_ref_init_ambiguous)
                      << DestType << OnlyArg->getType()
                      << Args[0]->getSourceRange())),
           S, OCD_AmbiguousCandidates, Args);
       break;
 
+    case OR_Exposure:
     case OR_No_Viable_Function: {
       auto Cands = FailedCandidateSet.CompleteCandidates(S, OCD_AllCandidates, Args);
       if (!S.RequireCompleteType(Kind.getLocation(),
                                  DestType.getNonReferenceType(),
                           diag::err_typecheck_nonviable_condition_incomplete,
                                OnlyArg->getType(), Args[0]->getSourceRange()))
         S.Diag(Kind.getLocation(), diag::err_typecheck_nonviable_condition)
           << (Entity.getKind() == InitializedEntity::EK_Result)
switch (FailedOverloadResult) {
       case OR_Ambiguous:
         FailedCandidateSet.NoteCandidates(
             PartialDiagnosticAt(Kind.getLocation(),
                                 S.PDiag(diag::err_ovl_ambiguous_init)
                                     << DestType << ArgsRange),
             S, OCD_AmbiguousCandidates, Args);
         break;
 
+      case OR_Exposure:
       case OR_No_Viable_Function:
         if (Kind.getKind() == InitializationKind::IK_Default &&
             (Entity.getKind() == InitializedEntity::EK_Base ||
              Entity.getKind() == InitializedEntity::EK_Member ||
              Entity.getKind() == InitializedEntity::EK_ParenAggInitMember) &&
             isa<CXXConstructorDecl>(S.CurContext)) {
           // This is implicit default initialization of a member or
           // base within a constructor. If no viable function was
case OR_Ambiguous:
     Candidates.NoteCandidates(
         PartialDiagnosticAt(
             Kind.getLocation(),
             PDiag(diag::err_deduced_class_template_ctor_ambiguous)
                 << TemplateName),
         *this, OCD_AmbiguousCandidates, Inits);
     return QualType();
 
+  case OR_Exposure:
   case OR_No_Viable_Function: {
     CXXRecordDecl *Primary =
         cast<ClassTemplateDecl>(Template)->getTemplatedDecl();
     bool Complete =
         isCompleteType(Kind.getLocation(), Context.getTypeDeclType(Primary));
     Candidates.NoteCandidates(
         PartialDiagnosticAt(
             Kind.getLocation(),

clang/lib/Sema/SemaLookup.cpp

case OR_Deleted:
       Result->setKind(SpecialMemberOverloadResult::NoMemberOrDeleted);
       break;
 
     case OR_Ambiguous:
       Result->setMethod(nullptr);
       Result->setKind(SpecialMemberOverloadResult::Ambiguous);
       break;
 
+    case OR_Exposure:
     case OR_No_Viable_Function:
       Result->setMethod(nullptr);
       Result->setKind(SpecialMemberOverloadResult::NoMemberOrDeleted);
       break;
   }
 
   return *Result;
 }

clang/lib/Sema/SemaModule.cpp

 //===--- SemaModule.cpp - Semantic Analysis for Modules -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements semantic analysis for modules (C++ modules syntax,
 //  Objective-C modules syntax, and Clang header modules).
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTConsumer.h"
+#include "clang/AST/StmtVisitor.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/StringExtras.h"
 #include <optional>
 
 using namespace clang;
 using namespace sema;
bool Sema::isModuleUnitOfCurrentTU(const Module *M) const {
 
   // If we are not in a module currently, M must not be the module unit of
   // current TU.
   if (!CurrentModuleUnit)
     return false;
 
   return M->isSubModuleOf(CurrentModuleUnit->getTopLevelModule());
 }
+
+bool Sema::diagnoseFunctionBodyExposures(const NamedDecl *D,
+                                         SourceLocation Loc) {
+
+  FunctionDecl *Current = getCurFunctionDecl();
+
+  if (!Current || Current->isInvalidDecl() || D->isInvalidDecl())
+    return false;
+
+  if (Current->isStatic())
+    return false;
+
+  if (auto *PD = dyn_cast<ParmVarDecl>(D))
+    return false;
+  if (auto *VD = dyn_cast<VarDecl>(D)) {
+    if (VD->getType()->isDependentType())
+      return false;
+  }
+
+  if ((Current->isInlineSpecified() || Current->isConstexpr()) &&
+      isCurrentModulePurview() &&
+      Current->getTemplatedKind() ==
+          FunctionDecl::TemplatedKind::TK_NonTemplate) {
+    if (isTULocal(D)) {
+      Diag(Loc, diag::err_use_is_exposure) << D;
+      return true;
+    }
+  }
+  return false;
+}
+
+class DeclRefIsExposure : public ConstStmtVisitor<DeclRefIsExposure, void> {
+public:
+  /// Find a DeclRefExpr in the given expression.
+  static bool check(Sema &S, const Expr *E, SourceLocation L) {
+    DeclRefIsExposure R(S, L);
+    R.Visit(E);
+    return R.getResult();
+  }
+
+  /// Find a DeclRefExpr in the given statment.
+  static bool check(Sema &S, const Stmt *C, SourceLocation L) {
+    DeclRefIsExposure R(S, L);
+    R.Visit(C);
+    return R.getResult();
+  }
+
+  void VisitDeclRefExpr(const DeclRefExpr *DR) {
+    const ValueDecl *V = DR->getDecl();
+
+    if (S.isTULocal(V)) {
+      S.Diag(L, diag::err_use_is_exposure) << V;
+      Result = true;
+    }
+  }
+  void VisitExpr(const Expr *E) {
+    for (auto *Ch : E->children())
+      if (Ch)
+        Visit(Ch);
+  }
+
+  void VisitStmt(const Stmt *S) {
+    for (auto *Ch : S->children())
+      if (Ch)
+        Visit(Ch);
+  }
+
+  bool getResult() { return Result; }
+
+private:
+  DeclRefIsExposure(Sema &S, SourceLocation L) : S(S), L(L) {}
+  Sema &S;
+  SourceLocation L;
+  bool Result = false;
+};
+
+class LambdaExprIsExposure : public ConstStmtVisitor<LambdaExprIsExposure, void> {
+public:
+  /// Find a LambdaExpr in the given expression.
+  static bool check(Sema &S, const Expr *E, SourceLocation L) {
+    LambdaExprIsExposure R(S, L);
+    R.Visit(E);
+    return R.getResult();
+  }
+
+  void VisitLambdaExpr(const LambdaExpr *LM) {
+    auto *LD = LM->getLambdaClass();
+    S.Diag(L, diag::err_use_is_exposure) << LD;
+    Result = true;
+  }
+
+  void VisitExpr(const Expr *E) {
+    for (auto *Ch : E->children())
+      if (Ch)
+        Visit(Ch);
+  }
+
+  void VisitStmt(const Stmt *S) {
+    for (auto *Ch : S->children())
+      if (Ch)
+        Visit(Ch);
+  }
+
+  bool getResult() { return Result; }
+
+private:
+  LambdaExprIsExposure(Sema &S, SourceLocation L) : S(S), L(L) {}
+  Sema &S;
+  SourceLocation L;
+  bool Result = false;
+};
+
+bool Sema::diagnoseVarInitExposures(const VarDecl *VDecl, const Expr *Init,
+                                    bool OnlyLambdaExpr) {
+
+  bool Res;
+  if (OnlyLambdaExpr) {
+    Res = LambdaExprIsExposure::check(*this, Init, VDecl->getLocation());
+  } else {
+    Res = DeclRefIsExposure::check(*this, Init, VDecl->getLocation());
+  }
+  return Res;
+}
+
+bool Sema::diagnoseExprExposure(const Expr *E) {
+
+  if (DeclRefIsExposure::check(*this, E, E->getExprLoc())) {
+    // llvm::dbgs() << "expr exposure: "; E->dump();
+    return true;
+  }
+  return false;
+}
+
+bool Sema::diagnoseInstantiationExposure(const FunctionDecl *F,
+                                         SourceLocation L) {
+
+  if (F->getOwningModule() &&
+      (F->getOwningModule() != getCurrentModule() ||
+       !currentModuleIsInterface()) &&
+      DeclRefIsExposure::check(*this, F->getBody(), L)) {
+    // llvm::dbgs() << "expr exposure: "; E->dump();
+    return true;
+  }
+  return false;
+}

clang/lib/Sema/SemaOverload.cpp

case OR_Ambiguous:
     ICS.Ambiguous.setToType(ToType);
     for (OverloadCandidateSet::iterator Cand = Conversions.begin();
          Cand != Conversions.end(); ++Cand)
       if (Cand->Best)
         ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
     break;
 
     // Fall through.
+  case OR_Exposure:
   case OR_No_Viable_Function:
     ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
     break;
   }
 
   return ICS;
 }
 
case OR_Success: {
     User.ConversionFunction = Constructor;
     User.FoundConversionFunction = Best->FoundDecl;
     User.After.setAsIdentityConversion();
     User.After.setFromType(ThisType->castAs<PointerType>()->getPointeeType());
     User.After.setAllToTypes(ToType);
     return Result;
   }
 
+  case OR_Exposure:
+    return OR_Exposure;
   case OR_No_Viable_Function:
     return OR_No_Viable_Function;
   case OR_Ambiguous:
     return OR_Ambiguous;
   }
 
   llvm_unreachable("Invalid OverloadResult!");
 }
if (CXXConversionDecl *Conversion
       User.After = Best->FinalConversion;
       return Result;
     }
     llvm_unreachable("Not a constructor or conversion function?");
 
   case OR_No_Viable_Function:
     return OR_No_Viable_Function;
 
+  case OR_Exposure:
+    return OR_Exposure;
+
   case OR_Ambiguous:
     return OR_Ambiguous;
   }
 
   llvm_unreachable("Invalid OverloadResult!");
 }
 
 bool
FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS,
   case OR_Ambiguous:
     ICS.setAmbiguous();
     for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
          Cand != CandidateSet.end(); ++Cand)
       if (Cand->Best)
         ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
     return true;
 
+  case OR_Exposure:
   case OR_No_Viable_Function:
   case OR_Deleted:
     // There was no suitable conversion, or we found a deleted
     // conversion; continue with other checks.
     return false;
   }
 
   llvm_unreachable("Invalid OverloadResult!");
case OR_Success: {
       if (recordConversion(*this, Loc, From, Converter, T,
                            HadMultipleCandidates, Found))
         return ExprError();
       break;
     }
     case OR_Ambiguous:
       return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
                                          ViableConversions);
+    case OR_Exposure:
     case OR_No_Viable_Function:
       if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
                                      HadMultipleCandidates,
                                      ExplicitConversions))
         return ExprError();
       [[fallthrough]];
     case OR_Deleted:
       // We'll complain below about a non-integral condition type.
void Sema::AddOverloadCandidate(
   // allowing them in this context, but keep them around so we can point
   // to them in diagnostics.
   if (!AllowExplicit && ExplicitSpecifier::getFromDecl(Function).isExplicit()) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_explicit;
     return;
   }
 
-  // Functions with internal linkage are only viable in the same module unit.
-  if (getLangOpts().CPlusPlusModules && Function->isInAnotherModuleUnit()) {
+  if (auto *MF = Function->getOwningModule()) {
+    if (getLangOpts().CPlusPlusModules && !MF->isModuleMapModule()) {
       /// FIXME: Currently, the semantics of linkage in clang is slightly
       /// different from the semantics in C++ spec. In C++ spec, only names
       /// have linkage. So that all entities of the same should share one
       /// linkage. But in clang, different entities of the same could have
       /// different linkage.
       NamedDecl *ND = Function;
       if (auto *SpecInfo = Function->getTemplateSpecializationInfo())
         ND = SpecInfo->getTemplate();
 
+      // We need only check cases that originate from a different TU (i.e. have
+      // been imported)
+      if (ND->isInAnotherModuleUnit()) {
         if (ND->getFormalLinkage() == Linkage::InternalLinkage) {
+          // Functions with internal linkage are only viable in the same TU.
+          // llvm::dbgs() << "exposure: ";
+          // Function->dump();
+          Candidate.Viable = false;
+          Candidate.FailureKind = ovl_fail_module_exposure;
+          return;
+        } else if (ND->getFormalLinkage() == Linkage::ModuleLinkage &&
+                   !arePartOfSameNamedModule(ND->getOwningModule(), MF)) {
+          // Functions with module linkage are only viable in the same module.
+          // llvm::dbgs() << "not part of this module: ";
+          // Function->dump();
           Candidate.Viable = false;
           Candidate.FailureKind = ovl_fail_module_mismatched;
           return;
         }
       }
+    }
+  }
 
   if (Function->isMultiVersion() &&
       ((Function->hasAttr<TargetAttr>() &&
         !Function->getAttr<TargetAttr>()->isDefaultVersion()) ||
        (Function->hasAttr<TargetVersionAttr>() &&
         !Function->getAttr<TargetVersionAttr>()->isDefaultVersion()))) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_non_default_multiversion_function;
OverloadCandidateSet::BestViableFunction(Sema &S, SourceLocation Loc,
   // Find the best viable function.
   Best = end();
   for (auto *Cand : Candidates) {
     Cand->Best = false;
     if (Cand->Viable) {
       if (Best == end() ||
           isBetterOverloadCandidate(S, *Cand, *Best, Loc, Kind))
         Best = Cand;
+    } else if (Cand->FailureKind == ovl_fail_module_exposure) {
+      // This candidate is an exposure and invalidates the whole set.
+      Best = end();
+      return OR_Exposure;
     } else if (Cand->NotValidBecauseConstraintExprHasError()) {
       // This candidate has constraint that we were unable to evaluate because
       // it referenced an expression that contained an error. Rather than fall
       // back onto a potentially unintended candidate (made worse by
       // subsuming constraints), treat this as 'no viable candidate'.
       Best = end();
       return OR_No_Viable_Function;
     }
case ovl_fail_constraints_not_satisfied: {
     S.Diag(Fn->getLocation(),
            diag::note_ovl_candidate_constraints_not_satisfied)
         << (unsigned)FnKindPair.first << (unsigned)ocs_non_template
         << FnDesc /* Ignored */;
     ConstraintSatisfaction Satisfaction;
     if (S.CheckFunctionConstraints(Fn, Satisfaction))
       break;
     S.DiagnoseUnsatisfiedConstraint(Satisfaction);
+    break;
   }
+  case ovl_fail_module_exposure:
+    S.Diag(Fn->getLocation(),
+           diag::note_ovl_candidate_is_exposure)
+      << Fn;
+    return;
+    break;
   }
 }
 
 static void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand) {
   if (shouldSkipNotingLambdaConversionDecl(Cand->Surrogate))
     return;
 
   // Desugar the type of the surrogate down to a function type,
case OCD_ViableCandidates:
       if (!Cand->Viable)
         continue;
       break;
 
     case OCD_AmbiguousCandidates:
       if (!Cand->Best)
         continue;
       break;
+
+    case OCD_ExposureCandidates:
+      if (Cand->Viable || Cand->FailureKind != ovl_fail_module_exposure)
+        continue;
+      break;
     }
 
     Cands.push_back(Cand);
   }
 
   llvm::stable_sort(
       Cands, CompareOverloadCandidatesForDisplay(S, OpLoc, Args.size(), Kind));
 
case OR_Success: {
     if (SemaRef.DiagnoseUseOfDecl(FDecl, ULE->getNameLoc()))
       return ExprError();
     Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
     return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
                                          ExecConfig, /*IsExecConfig=*/false,
                                          (*Best)->IsADLCandidate);
   }
 
+  case OR_Exposure:
   case OR_No_Viable_Function: {
     // Try to recover by looking for viable functions which the user might
     // have meant to call.
     ExprResult Recovery = BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc,
                                                 Args, RParenLoc,
                                                 CandidateSet->empty(),
                                                 AllowTypoCorrection);
     if (Recovery.isInvalid() || Recovery.isUsable())
for (const Expr *Arg : Args) {
                                                        Arg->getExprLoc()))
           return ExprError();
       }
     }
 
     CandidateSet->NoteCandidates(
         PartialDiagnosticAt(
             Fn->getBeginLoc(),
-            SemaRef.PDiag(diag::err_ovl_no_viable_function_in_call)
+            SemaRef.PDiag(OverloadResult == OR_Exposure ? diag::err_ovl_exposure_function_in_call : diag::err_ovl_no_viable_function_in_call)
                 << ULE->getName() << Fn->getSourceRange()),
-        SemaRef, OCD_AllCandidates, Args);
+        SemaRef, OverloadResult == OR_Exposure ? OCD_ExposureCandidates : OCD_AllCandidates, Args);
     break;
   }
 
   case OR_Ambiguous:
     CandidateSet->NoteCandidates(
         PartialDiagnosticAt(Fn->getBeginLoc(),
                             SemaRef.PDiag(diag::err_ovl_ambiguous_call)
                                 << ULE->getName() << Fn->getSourceRange()),
if (FnDecl) {
           CCK_ForBuiltinOverloadedOp);
       if (InputRes.isInvalid())
         return ExprError();
       Input = InputRes.get();
       break;
     }
   }
 
+  case OR_Exposure:
   case OR_No_Viable_Function:
     // This is an erroneous use of an operator which can be overloaded by
     // a non-member function. Check for non-member operators which were
     // defined too late to be candidates.
     if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, ArgsArray))
       // FIXME: Recover by calling the found function.
       return ExprError();
 
case OR_Success: {
             AA_Passing, CCK_ForBuiltinOverloadedOp);
         if (ArgsRes1.isInvalid())
           return ExprError();
         Args[1] = ArgsRes1.get();
         break;
       }
     }
 
+    case OR_Exposure:
     case OR_No_Viable_Function: {
       // C++ [over.match.oper]p9:
       //   If the operator is the operator , [...] and there are no
       //   viable functions, then the operator is assumed to be the
       //   built-in operator and interpreted according to clause 5.
       if (Opc == BO_Comma)
         break;
 
case OR_Success: {
         if (ArgsRes1.isInvalid())
           return ExprError();
         Args[1] = ArgsRes1.get();
 
         break;
       }
     }
 
+    case OR_Exposure:
     case OR_No_Viable_Function: {
       PartialDiagnostic PD =
           CandidateSet.empty()
               ? (PDiag(diag::err_ovl_no_oper)
                  << Args[0]->getType() << /*subscript*/ 0
                  << Args[0]->getSourceRange() << Range)
               : (PDiag(diag::err_ovl_no_viable_subscript)
                  << Args[0]->getType() << Args[0]->getSourceRange() << Range);
case OR_Success:
       // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
       // being used.
       if (Method != FoundDecl.getDecl() &&
           DiagnoseUseOfOverloadedDecl(Method, UnresExpr->getNameLoc()))
         break;
       Succeeded = true;
       break;
 
+    case OR_Exposure:
     case OR_No_Viable_Function:
       CandidateSet.NoteCandidates(
           PartialDiagnosticAt(
               UnresExpr->getMemberLoc(),
               PDiag(diag::err_ovl_no_viable_member_function_in_call)
                   << DeclName << MemExprE->getSourceRange()),
           *this, OCD_AllCandidates, Args);
       break;
Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
   OverloadCandidateSet::iterator Best;
   switch (CandidateSet.BestViableFunction(*this, Object.get()->getBeginLoc(),
                                           Best)) {
   case OR_Success:
     // Overload resolution succeeded; we'll build the appropriate call
     // below.
     break;
 
+  case OR_Exposure:
   case OR_No_Viable_Function: {
     PartialDiagnostic PD =
         CandidateSet.empty()
             ? (PDiag(diag::err_ovl_no_oper)
                << Object.get()->getType() << /*call*/ 1
                << Object.get()->getSourceRange())
             : (PDiag(diag::err_ovl_no_viable_object_call)
                << Object.get()->getType() << Object.get()->getSourceRange());
Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc,
 
   // Perform overload resolution.
   OverloadCandidateSet::iterator Best;
   switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
   case OR_Success:
     // Overload resolution succeeded; we'll build the call below.
     break;
 
+  case OR_Exposure:
   case OR_No_Viable_Function: {
     auto Cands = CandidateSet.CompleteCandidates(*this, OCD_AllCandidates, Base);
     if (CandidateSet.empty()) {
       QualType BaseType = Base->getType();
       if (NoArrowOperatorFound) {
         // Report this specific error to the caller instead of emitting a
         // diagnostic, as requested.
         *NoArrowOperatorFound = true;
ExprResult Sema::BuildLiteralOperatorCall(LookupResult &R,
   // Perform overload resolution. This will usually be trivial, but might need
   // to perform substitutions for a literal operator template.
   OverloadCandidateSet::iterator Best;
   switch (CandidateSet.BestViableFunction(*this, UDSuffixLoc, Best)) {
   case OR_Success:
   case OR_Deleted:
     break;
 
+  case OR_Exposure:
   case OR_No_Viable_Function:
     CandidateSet.NoteCandidates(
         PartialDiagnosticAt(UDSuffixLoc,
                             PDiag(diag::err_ovl_no_viable_function_in_call)
                                 << R.getLookupName()),
         *this, OCD_AllCandidates, Args);
     return ExprError();
 
if (!MemberLookup.empty()) {
     if (CandidateSet->empty() || CandidateSetError) {
       *CallExpr = ExprError();
       return FRS_NoViableFunction;
     }
     OverloadCandidateSet::iterator Best;
     OverloadingResult OverloadResult =
         CandidateSet->BestViableFunction(*this, Fn->getBeginLoc(), Best);
 
-    if (OverloadResult == OR_No_Viable_Function) {
+    if (OverloadResult == OR_No_Viable_Function || OverloadResult == OR_Exposure) {
       *CallExpr = ExprError();
       return FRS_NoViableFunction;
     }
     *CallExpr = FinishOverloadedCallExpr(*this, S, Fn, Fn, Loc, Range,
                                          Loc, nullptr, CandidateSet, &Best,
                                          OverloadResult,
                                          /*AllowTypoCorrection=*/false);
     if (CallExpr->isInvalid() || OverloadResult != OR_Success) {

clang/lib/Sema/SemaTemplateInstantiateDecl.cpp

if (PatternDecl->hasSkippedBody()) {
       if (Body.isInvalid())
         Function->setInvalidDecl();
     }
     // FIXME: finishing the function body while in an expression evaluation
     // context seems wrong. Investigate more.
     ActOnFinishFunctionBody(Function, Body.get(), /*IsInstantiation=*/true);
 
     PerformDependentDiagnostics(PatternDecl, TemplateArgs);
+    if (getLangOpts().CPlusPlusModules && !Function->isInvalidDecl() &&
+        diagnoseInstantiationExposure(Function, PointOfInstantiation))
+      Function->setInvalidDecl();
 
     if (auto *Listener = getASTMutationListener())
       Listener->FunctionDefinitionInstantiated(Function);
 
     savedContext.pop();
   }
 
   DeclGroupRef DG(Function);

clang/test/CXX/basic/basic.link/p14-additions.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/A.cpp -fsyntax-only -Wno-unused-value -verify
+
+//--- A.cpp
+
+export module A;
+
+static constexpr int f() { return 0; }
+int a = 10;
+
+// extra decltype() tests
+
+static decltype(f()) s; // OK
+       decltype(f()) g; // expected-error {{use of TU-local entity 'f' is an exposure}}
+export decltype(f()) e; // expected-error {{use of TU-local entity 'f' is an exposure}}
+
+static decltype(f()) *fps; // OK
+       decltype(f()) *fpg; // expected-error {{use of TU-local entity 'f' is an exposure}}
+export decltype(f()) *fpe; // expected-error {{use of TU-local entity 'f' is an exposure}}
+
+static decltype(f()) &frs = a; // OK
+       decltype(f()) &frg = a; // expected-error {{use of TU-local entity 'f' is an exposure}}
+export decltype(f()) &fre = a; // expected-error {{use of TU-local entity 'f' is an exposure}}
+
+// auto cases ..
+
+static auto fa_internal() { return f(); } // OK
+       auto fa_module() { return f(); }   // OK
+export auto fa_export() { return f(); }   // OK
+
+static auto inline fai_internal() { return f(); } // OK
+       auto inline fai_module() { return f(); }   // expected-error {{use of TU-local entity 'f' is an exposure}}
+export auto inline fai_export() { return f(); }   // expected-error {{use of TU-local entity 'f' is an exposure}}K
+
+static auto constexpr fac_internal() { return f(); } // OK
+       auto constexpr fac_module() { return f(); }   // expected-error {{use of TU-local entity 'f' is an exposure}}
+export auto constexpr fac_export() { return f(); }   // expected-error {{use of TU-local entity 'f' is an exposure}}K
+
+// extra constexpr variable checks.
+
+static constexpr int v_internal_constexpr = f(); // OK
+       constexpr int v_module_constexpr  = f();  // expected-error {{use of TU-local entity 'f' is an exposure}}
+export constexpr int v_exported_constexpr = f(); // expected-error {{use of TU-local entity 'f' is an exposure}}

clang/test/CXX/basic/basic.link/p1498r1-2-2-1.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/A.cpp -fsyntax-only -Wno-unused-value -verify
+
+//--- A.cpp
+
+export module A;
+
+static constexpr int f() { return 0; }
+
+static int f_internal() { return f(); } // OK
+       int f_module()   { return f(); } // OK
+export int f_exported() { return f(); } // OK
+
+static inline int f_internal_inline() { return f(); } // OK
+       inline int f_module_inline()   { return f(); } // expected-error {{use of TU-local entity 'f' is an exposure}}
+export inline int f_exported_inline() { return f(); } // expected-error {{use of TU-local entity 'f' is an exposure}}
+
+static constexpr int f_internal_constexpr() { return f(); } // OK
+       constexpr int f_module_constexpr()   { return f(); } // expected-error {{use of TU-local entity 'f' is an exposure}}
+export constexpr int f_exported_constexpr() { return f(); } // expected-error {{use of TU-local entity 'f' is an exposure}}
+
+static consteval int f_internal_consteval() { return f(); } // OK
+       consteval int f_module_consteval()   { return f(); } // expected-error {{use of TU-local entity 'f' is an exposure}}
+export consteval int f_exported_consteval() { return f(); } // expected-error {{use of TU-local entity 'f' is an exposure}}
+
+static decltype(f()) f_internal_decltype() { return 0; } // OK
+       decltype(f()) f_module_decltype()   { return 0; } // expected-error {{use of TU-local entity 'f' is an exposure}}
+export decltype(f()) f_exported_decltype() { return 0; } // expected-error {{use of TU-local entity 'f' is an exposure}}

clang/test/CXX/basic/basic.link/p1498r1-2-2-5.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/A.cpp -fsyntax-only -Wno-unused-value -verify
+
+//--- A.cpp
+
+export module A;
+
+static constexpr int f() { return 0; }
+
+static int v_internal = f(); // OK
+       int v_module   = f(); // OK
+export int v_exported = f(); // OK
+
+static inline int v_internal_inline = f(); // OK
+       inline int v_module_inline   = f(); // expected-error {{use of TU-local entity 'f' is an exposure}}
+export inline int v_exported_inline = f(); // expected-error {{use of TU-local entity 'f' is an exposure}}
+
+struct c_sdm_module {
+  static int sdm_module;
+  static constexpr int sdm_module_constexpr = f(); // expected-error {{use of TU-local entity 'f' is an exposure}}
+};
+
+int c_sdm_module::sdm_module = f(); // OK

clang/test/CXX/basic/basic.link/p19-ex4.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+// RUN: cd %t
+//
+// RUN: %clang_cc1 -std=c++20 A.cpp -fsyntax-only -DTEST_INTERFACE \
+// RUN: -Wno-unused-value -verify
+// RUN: %clang_cc1 -std=c++20 A.cpp -emit-module-interface -o A.pcm \
+// RUN: -Wno-unused-value
+// RUN: %clang_cc1 -std=c++20 A-impl.cpp -fsyntax-only -fmodule-file=A=A.pcm \
+// RUN: -Wno-unused-value -verify
+
+//--- A.cpp
+export module A;
+static void f() {}
+static int fi() { return 1; }
+#if TEST_INTERFACE
+inline void it() { f(); }           // expected-error {{use of TU-local entity 'f' is an exposure}}
+#endif
+static inline void its() { f(); }   // OK
+template<int> void g() { its(); }   // OK
+template void g<0>();
+
+#if TEST_INTERFACE
+                                    // error: f (though not its type) is TU-local
+decltype(f) *fp;                    // expected-error {{use of TU-local entity 'f' is an exposure}}
+#endif
+auto &fr = f;                       // OK
+#if TEST_INTERFACE
+constexpr auto &fr2 = fr;           // expected-error {{use of TU-local entity 'f' is an exposure}}
+#endif
+constexpr static auto fp2 = fr;     // OK
+
+struct S { void (&ref)(); } s{f};               // OK, value is TU-local
+constexpr extern struct W { S &s; } wrap{s};    // OK, value is not TU-local
+
+static auto x = []{f();};           // OK
+#if TEST_INTERFACE
+auto x2 = x;                        // expected-error {{use of TU-local entity 'x' is an exposure}}
+int y = ([]{f();}(),0);             // expected-error-re {{use of TU-local entity '(lambda at {{.*}})' is an exposure}}
+#endif
+int y2 = (x,0);                     // OK
+
+namespace N {
+  struct A {};
+  void adl(A);
+  static void adl(int);
+}
+void adl(double);
+
+inline void h(auto x) { adl(x); }   // OK, but a specialization might be an exposure
+
+//--- A-impl.cpp
+module A;
+void other() {
+  g<0>();                           // OK, specialization is explicitly instantiated
+  g<1>();                           // expected-error {{use of TU-local entity 'its' is an exposure}}
+                                    // expected-note@-1 {{in instantiation of function template specialization 'g<1>' requested here}}
+  h(N::A{});                        // [e-mail]:38 {{the overload set for the call to 'adl' contains one or more exposures}}
+                                    // expected-note@-1 {{in instantiation of function template specialization 'h<N::A>' requested here}}
+                                    // [e-mail]:34 {{candidate 'adl' is an exposure}}
+  h(0);                             // OK, calls adl(double)
+  adl(N::A{});                      // OK; N::adl(int) not found, calls N::adl(N::A)
+  fr();                             // OK, calls f
+                                    // error: fr is not usable in constant expressions here
+  constexpr auto ptr = fr;          // expected-error {{use of TU-local entity 'f' is an exposure}}
+}

clang/test/CXX/basic/basic.link/p19-inline-vars.cpp

+// RUN: %clang_cc1 -std=c++20 %s -fsyntax-only -Wno-unused-value -verify
+
+export module A;
+
+static int fi() { return 1; }
+static int x = 10;
+
+inline int bad_f0() { return x; }  // expected-error {{use of TU-local entity 'x' is an exposure}}
+
+static inline int ok_f0() {  return x; }  // OK
+
+inline int bad_v0 = fi();      // expected-error {{use of TU-local entity 'fi' is an exposure}}
+inline int bad_v1 = 5 + x - fi();   // expected-error {{use of TU-local entity 'x' is an exposure}}
+                                    // expected-error@-1 {{use of TU-local entity 'fi' is an exposure}}
+
+static inline int ok_v0 = fi(); // OK
+static inline int ok_v1 = x;  // OK

clang/test/CXX/basic/basic.lookup/basic.lookup.argdep/p5-ex2.cpp

void test() {
 
   // error: S::f in module M not considered even though S is an associated
   // namespace, since the entity Z is in a different module from f.
   f(x, S::Z()); // expected-error {{no matching function for call to 'f'}}
   // [e-mail]:4 {{candidate function not viable: requires 1 argument, but 2 were provided}}
 
   // error: S::f is visible in instantiation context, but  R::g has internal
   // linkage and cannot be used outside N.cpp
-  apply(x, S::Z()); // [e-mail]:10 {{no matching function for call to 'g'}}
+  apply(x, S::Z()); // [e-mail]:10 {{the overload set for the call to 'g' contains one or more exposures}}
                     // expected-note@-1 {{in instantiation of function template specialization 'apply<R::X, S::Z>' requested here}}
+                    // [e-mail]:5 {{candidate 'g' is an exposure}}
 }

clang/test/Modules/lambdas.cppm

 // RUN: rm -rf %t
 // RUN: mkdir -p %t
 // RUN: split-file %s %t
 //
 // RUN: %clang_cc1 -std=c++20 %t/lambdas.cppm -emit-module-interface \
 // RUN:    -o %t/lambdas.pcm
 // RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -fsyntax-only \
 // RUN:    -verify
-//
-// RUN: %clang_cc1 -std=c++20 %t/lambdas2.cppm -emit-module-interface \
-// RUN:    -o %t/lambdas2.pcm
-// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -fsyntax-only \
-// RUN:    -verify -DUSE_LAMBDA2
 
 //--- lambdas.h
 auto l1 = []() constexpr -> int {
     return 43;
 };
 // 
 auto l2 = []() constexpr -> double {
     return 3.0;

 module;
 #include "lambdas.h"
 export module lambdas;
 export using ::l1;
 export using ::l2;
 export using ::l3;
 export using ::l4;
 
-//--- lambdas2.cppm
-export module lambdas2;
-export {
-#include "lambdas.h"  
-}
-
 //--- Use.cpp
 // expected-no-diagnostics
-#ifndef USE_LAMBDA2
 import lambdas;
-#else
-import lambdas2;
-#endif
 
 static_assert(l1.operator()() == 43);
 
 static_assert(l2.operator()() == 3.0);
 
 static_assert(l3.operator()(8.4) == 8);
  
 static_assert(l4(4, 12) == 16);
 static_assert(l4(5, 20) == 25);

clang/test/Modules/template-lambdas.cppm

 // RUN: rm -rf %t
 // RUN: mkdir -p %t
 // RUN: split-file %s %t
 //
 // RUN: %clang_cc1 -std=c++20 %t/template_lambdas.cppm -emit-module-interface \
 // RUN:    -o %t/lambdas.pcm
 // RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -fsyntax-only \
 // RUN:    -verify
-//
-// RUN: %clang_cc1 -std=c++20 %t/template_lambdas2.cppm -emit-module-interface \
-// RUN:    -o %t/lambdas2.pcm
-// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -fsyntax-only \
-// RUN:    -verify -DUSE_LAMBDA2
 
 //--- lambdas.h
 auto l1 = []<int I>() constexpr -> int {
     return I;
 };
 
 auto l2 = []<auto I>() constexpr -> decltype(I) {
     return I;

 module;
 #include "lambdas.h"
 export module lambdas;
 export using ::l1;
 export using ::l2;
 export using ::l3;
 export using ::l4;
 
-//--- template_lambdas2.cppm
-export module lambdas2;
-export {
-#include "lambdas.h"  
-}
-
 //--- Use.cpp
 // expected-no-diagnostics
-#ifndef USE_LAMBDA2
 import lambdas;
-#else
-import lambdas2;
-#endif
 
 static_assert(l1.operator()<5>() == 5);
 static_assert(l1.operator()<6>() == 6);
 
 static_assert(l2.operator()<7>() == 7);
 static_assert(l2.operator()<nullptr>() == nullptr);
 
 static_assert(l3.operator()<int>(8.4) == 8);
 static_assert(l3.operator()<int>(9.9) == 9);
 
 template<typename T>
 struct DummyTemplate { };
 
 static_assert(l4(DummyTemplate<float>(), 12) == 12.0);
 static_assert(l4(DummyTemplate<int>(), 19.8) == 19);