[C++20] [Module] Support reachable definition initially/partially

[ChuanqiXu]

Summary

This fixes: https://bugs.llvm.org/show_bug.cgi?id=52281 and https://godbolt.org/z/81f3ocjfW.

This patch introduces a new kind of ModuleOwnershipKind as ReachableWhenImported. This intended the status for reachable described at: https://eel.is/c++draft/module.reach#3.

Note that this patch is not intended to support all semantics about reachable semantics. For example, this patch didn't implement discarded declarations in GMF. (https://eel.is/c++draft/module.global.frag#3).

According to my experience, this patch is important to use C++20 module actually. After this patch, people should be able to start to use module in practice. (There may be other bugs. I know some too).

Test Plan: check-all and https://godbolt.org/z/81f3ocjfW.

[ChuanqiXu]

Rebased

[ChuanqiXu]

Update comments.

[ChuanqiXu]

I think it would be better to resent this when it is more complete.

[ChuanqiXu]

Implement reachable definition initially/partially.

[ChuanqiXu]

ping~

[ChuanqiXu]

Rebase and update tests.

[rsmith]

Thanks for working on this!

clang/include/clang/AST/DeclBase.h

228

230

clang/lib/Sema/SemaLookup.cpp

1615

I think this should be AllowReachable not RequireReachable, since what it means is "allow default arguments that are reachable but not visible".

But more generally I'd like to see this bool replaced by an enum, eg:

enum class AcceptableKind { Visible, Reachable };

... and rename functions like this that take the enum to hasAcceptableDefaultArgument. It'd be nice to still provide hasVisibleFoo and hasReachableFoo as simple wrappers around the function that has the enum parameter to make the call sites more readable, but we should try to not duplicate the definitions of these functions.

1622–1625

There's no need to check both visibility and reachability here.

Also, you shouldn't be asking whether D has any reachable redeclaration; you should be asking whether D itself is reachable.

What I'd really like to see here is:

if (S.isAcceptable(D, Kind))

with a Sema::isAcceptable(const Decl *D, AcceptableKind Kind)

1660–1662

Please remove this check: we should define what "reachable" means for module map modules, even if we define it as being the same as "visible", rather than adding special cases that try to distinguish the two modes. We support combining module map modules and C++ modules in the same compilation, so we need a semantic model that supports both at once.

1671–1674

As previously, it's redundant to check both. (And if there were somehow a declaration that was visible but not reachable, this would be wrong -- but that should never happen.)

1708–1754

I don't like duplicating this code for the reachable / visible checks. Instead, please add a parameter for the kind (visible / reachable).

1859–1860

This is wrong; whether the declaration came from an AST file is irrelevant. Keep in mind that declarations in the same source file may come from an AST file if we're using a PCH, and declarations in a different source file may *not* come from an AST file if parse multiple source files into the same ASTContext. What we need to check here is whether M is the global module fragment of the current source file.

2076–2080

I don't think this is quite right. Given:

export module M {
export enum E1 { e1 };
enum E2 { e2 };
export using E2U = E2;
enum E3 { e3 };
export E3 f();

... the intent is:

import M;
int main() {
  auto a = E1::e1; // OK, namespace-scope name E1 is visible and e1 is reachable
  auto b = e1; // OK, namespace-scope name e1 is visible
  auto c = E2::e2; // error, namespace-scope name E2 is not visible
  auto d = e2; // error, namespace-scope name e2 is not visible
  auto e = E2U::e2; // OK, namespace-scope name E2U is visible and E2::e2 is reachable
  auto f = E3::e3; // error, namespace-scope name E3 is not visible
  auto g = e3; // error, namespace-scope name e3 is not visible
  auto h = decltype(f())::e3; // OK, namespace-scope name f is visible and E3::e3 is reachable
}

Instead of doing the check in this function, I think we need to consider the scope in which we're doing a lookup: if that scope is a class or enumeration scope, and the class or enumeration has a reachable definition, then we don't do any visibility checks for its members.

3859

We should look for a reachable definition here, not a reachable declaration.

[rsmith]

clang/lib/Sema/SemaLookup.cpp

2090

We should look for a reachable definition, not a reachable declaration.

clang/lib/Sema/SemaModule.cpp

340

This should not depend on whether the C++ modules language feature is enabled, it should depend on whether the current module is a module map module versus a C++ module.

Module map module semantics should be the same regardless of whether we're in C++20 mode.

clang/lib/Sema/SemaTemplate.cpp

11010

Use the enum here.

clang/lib/Sema/SemaType.cpp

8743

This can be a slow check; it'd be better to avoid doing it if we're in the overwhelmingly common case that the declaration is obviously reachable (because it's not module-private, and we're not trying to implement strict reachability semantics).

8757–8759

This isn't quite right: the same entity could have a declaration in a module map module and another declaration in a C++ header module. We need to check whether the entity has *any* declaration in a C++ module, not only whether D is in one.

8761–8764

A declaration not being from an AST file should not be assumed to imply that it appears in the same TU. A Clang-as-a-library user might parse multiple source files into a single ASTContext, and ASTImporter can be used to combine multiple source files into a single ASTContext.

8793–8796

We should have a flag here to control this behavior. The default should probably be that we enforce reachability as strictly as we can, for portability and to help users enforce an "import what you use" hygiene rule, but in any case, we should give users the choice.

clang/lib/Serialization/ASTReaderDecl.cpp

618–620

This doesn't explain what's special about the number 4. It would be better to say "Unknown ModuleOwnership kind". It might be better still to use a switch here, so that we get a compile-time error rather than a runtime error if a new kind is added and this code isn't updated.

[ChuanqiXu]

Address @rsmith's comments.

[ChuanqiXu]

@rsmith Thanks for your valuable input!

clang/lib/Sema/SemaLookup.cpp

2076–2080

Oh, your example makes sense. The current implementation would accept d and g unexpectedly. I spent some time to look into this one. And I find it is not so easy to fix. I left a FIXME below and I would file an issue if this patch landed. Do you think this is OK?

BTW, I feel like the wording of spec need to be adjusted too. From the wording, I feel like d and g should be accepted.

3859

Yeah, from the wording it should be reachable definition. But it would cause many failures if I write hasReachableDefinition/hasVisibleDefinition here. So it looks like a legacy defect. I chose to follow the original style here.

[ChuanqiXu]

Rebase with main.

[ChuanqiXu]

Code Cleanups

[ChuanqiXu]

@rsmith gentle ping~

[ChuanqiXu]

@rsmith gentle ping~

[iains]

I'm going to try rebasing my GMF elision code on top of this.

the test-suite changes could be made easier to read by using the file-split stuff we've been using for recent changes (I guess this is an older patch)?

clang/include/clang/AST/DeclBase.h

234–237

that is not going to be sufficient to exclude them - see D126694, we introduce a new category "ModuleUnreachable".

636–637

see D126694.

clang/lib/Sema/SemaLookup.cpp

1947

I think isModuleInterfaceUnit needs to include implementation partition units, since they also have a BMI (is isInterfaceOrPartition() the right thing to use here?

1958

could we separate this part of the change into a separate patch (along with the command line switch etc.) ?
it is not needed for standard compliance, right?

clang/lib/Serialization/ASTWriterDecl.cpp

1931

ModuleOwnershipKind? (and several cases below)

[ChuanqiXu]

Address comments.

[ChuanqiXu]

In D113545#3560940, @iains wrote:

the test-suite changes could be made easier to read by using the file-split stuff we've been using for recent changes (I guess this is an older patch)?

Done, this is pretty old. BTW, I've made an implementation internally and it is able to compile https://github.com/alibaba/async_simple/tree/CXX20Modules and this patch is main part of that. I want to say this one is tested more or less.

---

(This section might not be related to this revision)

Boris tried to compile it by GCC: https://github.com/boris-kolpackov/async_simple/tree/CXX20Modules but GCC fall in ICE

You could use this one as a (not complete) test suite.

clang/include/clang/AST/DeclBase.h

234–237

Yeah, I am not going to edit this to avoid unnecessary rebasing work.

clang/lib/Sema/SemaLookup.cpp

1947

I think we couldn't use isInterfaceOrPartition() here. The call for isModuleInterfaceUnit() here is sufficient. For example, we could find the example at [[ https://eel.is/c++draft/module.reach#example-1 | [module.reach]example 1 ]], here in Translation unit #5:, the definition of struct B is not reachable since the definition lives in an implementation unit. (We could make it valid by making all additional TU as reachable)

Also the module interface unit shouldn't include implementation partition unit according to the wording: [[ https://eel.is/c++draft/module.unit#2 | [module.unit]p2 ]]. I agree that it is confusing since implementation partition unit is importable. But this is not our fault.

[iains]

thanks for amending the test cases they are now much easier to read and maintain.

This looks like a useful step forward, hopefully we can resolve any outstanding issue soon and get it landed.

Did you try wider testing (e.g. with lldb and other parts of the toolchain?)

clang/lib/Sema/SemaLookup.cpp

1947

OK, perhaps I am missing something - just to clarify,...

In this (which I believe is legal like [module.unit] ex 1 TU 4.

module;
....
module Main;

import :ImplUnit; // this has a BMI which could contain reachable definitions, right?

...

[ChuanqiXu]

In D113545#3562658, @iains wrote:

Did you try wider testing (e.g. with lldb and other parts of the toolchain?)

Yeah, I tried some other testing including using modules slightly in SPEC2017 and some other C++ performance benchmarks to make sure the introduction of C++ modules wouldn't cause performance regression. But testing is never enough : )

[ChuanqiXu]

clang/lib/Sema/SemaLookup.cpp

1947

Yeah, I believe this is legal according to [module.reach]p1:

A translation unit U is necessarily reachable from a point P if U is a module interface unit on which the translation unit containing P has an interface dependency, or the translation unit containing P imports U, in either case prior to P.

Since module Main imports :ImplUnit directly, the :ImplUnit TU is necessarily reachable.

[iains]

clang/lib/Sema/SemaLookup.cpp

1947

(sorry for multiple iterations - I am trying to see if I missed some point ... )

... it seems to me that in valid code :ImplUnit can have Kind =
ModulePartitionInterface
or
ModulePartitionImplementation

the second is the special case of an implementation that provides a BMI also.

[ChuanqiXu]

clang/lib/Sema/SemaLookup.cpp

1947

Yes, this confused me for a relative long time. It is really confusing that module partition implementation unit is importable but not module interface unit. The standard often emphasize module interface unit. From my implementation and using experience, the implementor and user could treat module partition implementation unit as an implementation partition unit if we treat all additional implementation TU as reachable. (This is what we do internally)

[ChuanqiXu]

@iains Given @rsmith is too busy, would you like to review this one?

[ChuanqiXu]

@rsmith @iains gentle ping

[iains]

@ChuanqiXu - have you tried the test example from 10.6 ex1 - I did the impl as below, but the behaviour does not seem to be quite correct?
any thoughts?

As for review, I can try to pick up the "nits" but not sure that I know the instantiation sub=system too well, so it would be better if @rsmith could cast an eye over those parts.

let's discuss the 10.6 example first (I'd guess 10.7 cases will need to be reviewed too)

// RUN: rm -rf %t
// RUN: split-file %s %t
// RUN: cd %t

// RUN: %clang_cc1 -std=c++20 -emit-header-unit -xc++-header-unit-header std-10-6-ex1-decl.h \
// RUN: -o decl.pcm

// RUN: %clang_cc1 -std=c++20 -emit-header-unit -xc++-header-unit-header std-10-6-ex1-defn.h \
// RUN: -o defn.pcm

// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-6-ex1-stuff.cpp \
// RUN: -o stuff.pcm

// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-6-ex1-M1.cpp \
// RUN: -fmodule-file=stuff.pcm -o M1.pcm  -fmodule-file=defn.pcm

// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-6-ex1-M2.cpp \
// RUN: -fmodule-file=stuff.pcm -o M2.pcm  -fmodule-file=decl.pcm

// RUN: %clang_cc1 -std=c++20 std-10-6-ex1-use.cpp \
// RUN: -fmodule-file=M1.pcm -fmodule-file=M2.pcm  -fsyntax-only

//--- std-10-6-ex1-decl.h
struct X;

//--- std-10-6-ex1-defn.h
struct X {};

//--- std-10-6-ex1-stuff.cpp
export module stuff;
export template<typename T, typename U> void foo(T, U u) { auto v = u; }
export template<typename T, typename U> void bar(T, U u) { auto v = *u; }

//--- std-10-6-ex1-M1.cpp
export module M1;
import "std-10-6-ex1-defn.h"; // provides struct X {};
import stuff;

export template<typename T> void f(T t) {
  X x;
  foo(t, x); 
}

//--- std-10-6-ex1-M2.cpp
export module M2;
import "std-10-6-ex1-decl.h"; // provides struct X; (not a definition)

import stuff;
export template<typename T> void g(T t) {
  X *x;
  bar(t, x); 
}

//--- std-10-6-ex1-use.cpp
import M1;
import M2;

void test() {
  f(0);
  g(0);
}

(I think we might also have some issues with poor diagnostics for items in PMF (saying that an import is required before use, but of course that import is impossible - e.g. 10.5)

[iains]

as suspected, we also have a missing diagnostic in 10.7 ex1

// RUN: rm -rf %t
// RUN: split-file %s %t
// RUN: cd %t

// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-7-ex1-M-A.cpp \
// RUN: -o M-A.pcm

// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-7-ex1-M-B.cpp \
// RUN: -o M-B.pcm

// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-7-ex1-M-C.cpp \
// RUN: -fmodule-file=M-A.pcm -verify -fsyntax-only

// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-7-ex1-M.cpp \
// RUN: -o M.pcm -fmodule-file=M-A.pcm -fmodule-file=M-B.pcm

// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-7-ex1-X.cpp \
// RUN: -o X.pcm

// RUN: %clang_cc1 -std=c++20 std-10-7-ex1-use.cpp -fsyntax-only \
// RUN: -fmodule-file=M.pcm -fmodule-file=X.pcm -verify

//--- std-10-7-ex1-M-A.cpp
export module M:A;
export struct B;

//--- std-10-7-ex1-M-B.cpp
module M:B;
struct B {
  operator int();
};

//--- std-10-7-ex1-M-C.cpp
module M:C;
import :A;
B b1;   // expected-error {{variable has incomplete type 'B'}} 
        // [e-mail]:2 {{forward declaration of 'B'}}
//--- std-10-7-ex1-M.cpp
export module M;
export import :A;
import :B;
B b2;
export void f(B b = B());

//--- std-10-7-ex1-X.cpp
export module X;

//--- std-10-7-ex1-use.cpp
module X;
import M;
B b3;     // expected-error 1+{{definition of 'B' must be imported from module 'M:B' before it is required}} 
          // [e-mail]:2 1+{{definition here is not reachable}}
void g() { f(); }  // expected-error {{definition of 'B' must be imported from module 'M:B' before it is required}}
  // not sure of the actual diagnostic here ^ , it is not emitted.

[ChuanqiXu]

Add test from https://eel.is/c++draft/module.context#example-1

[ChuanqiXu]

In D113545#3598412, @iains wrote:

As for review, I can try to pick up the "nits" but not sure that I know the instantiation sub=system too well, so it would be better if @rsmith could cast an eye over those parts.

Yeah, @rsmith should be the best one to review this. But as you can find, this revision is opened for months... and the revision blocks many uses of C++20 modules. I really hope someone could push this forward... This was tested before internally.

let's discuss the 10.6 example first (I'd guess 10.7 cases will need to be reviewed too)

// RUN: rm -rf %t
// RUN: split-file %s %t
// RUN: cd %t

// RUN: %clang_cc1 -std=c++20 -emit-header-unit -xc++-header-unit-header std-10-6-ex1-decl.h \
// RUN: -o decl.pcm

// RUN: %clang_cc1 -std=c++20 -emit-header-unit -xc++-header-unit-header std-10-6-ex1-defn.h \
// RUN: -o defn.pcm

// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-6-ex1-stuff.cpp \
// RUN: -o stuff.pcm

// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-6-ex1-M1.cpp \
// RUN: -fmodule-file=stuff.pcm -o M1.pcm  -fmodule-file=defn.pcm

// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-6-ex1-M2.cpp \
// RUN: -fmodule-file=stuff.pcm -o M2.pcm  -fmodule-file=decl.pcm

// RUN: %clang_cc1 -std=c++20 std-10-6-ex1-use.cpp \
// RUN: -fmodule-file=M1.pcm -fmodule-file=M2.pcm  -fsyntax-only

//--- std-10-6-ex1-decl.h
struct X;

//--- std-10-6-ex1-defn.h
struct X {};

//--- std-10-6-ex1-stuff.cpp
export module stuff;
export template<typename T, typename U> void foo(T, U u) { auto v = u; }
export template<typename T, typename U> void bar(T, U u) { auto v = *u; }

//--- std-10-6-ex1-M1.cpp
export module M1;
import "std-10-6-ex1-defn.h"; // provides struct X {};
import stuff;

export template<typename T> void f(T t) {
  X x;
  foo(t, x); 
}

//--- std-10-6-ex1-M2.cpp
export module M2;
import "std-10-6-ex1-decl.h"; // provides struct X; (not a definition)

import stuff;
export template<typename T> void g(T t) {
  X *x;
  bar(t, x); 
}

//--- std-10-6-ex1-use.cpp
import M1;
import M2;

void test() {
  f(0);
  g(0);
}

Thanks for reporting this. I've add the tests. And https://eel.is/c++draft/module.context#7.4 says it is unspecified whether or not g(0) is valid. So I think the current behavior is valid here.

as suspected, we also have a missing diagnostic in 10.7 ex1

Yes, this was added before at clang/test/CXX/module/module.reach/ex1.cpp. And I add a FIXME there:

// FIXME: We should emit an error for unreachable definition of B.
void g() { f(); }

I'll file an issue for it once this landed. BTW, the compiler would behave properly if:

//--- M.cppm
export module M;
export import :A;
import :B;
export B foo();
export void f(B b = B());
//--- Use.cpp
export module X;
import M;
void g() { f(foo()); } // complains successfully

This looks even more straight forward.

(I think we might also have some issues with poor diagnostics for items in PMF (saying that an import is required before use, but of course that import is impossible - e.g. 10.5)

Yes, there are many problems. And as the title said, this is an initial implementation and these problems are not regression bugs so I feel like it should be good to fix them in later versions.

[ChuanqiXu]

Update comments for the test of [module.context]p7.

[iains]

I think it is helpful to collect the standard examples into one place (i.e. test/Modules) and name them for the standard version (i.e. cxx20-N-M-exO.cpp) .. because

• the details of the examples do change from one version of the standard to the next, because of changes in the normative text
• some of the examples illustrate more than one bullet point
• it makes it easier to find them for someone who is starting work on this area.

(not a big deal, but now we have some on one place and some in another - which is why I had missed that you already had one of the cases)

I will rebase my changes on this - and I have a patch for the 10.5 PMF issues (under test),

[ChuanqiXu]

In D113545#3601031, @iains wrote:

I think it is helpful to collect the standard examples into one place (i.e. test/Modules) and name them for the standard version (i.e. cxx20-N-M-exO.cpp) .. because

• the details of the examples do change from one version of the standard to the next, because of changes in the normative text
• some of the examples illustrate more than one bullet point
• it makes it easier to find them for someone who is starting work on this area.

(not a big deal, but now we have some on one place and some in another - which is why I had missed that you already had one of the cases)

I will rebase my changes on this - and I have a patch for the 10.5 PMF issues (under test),

I prefer to put them under test/CXX/module/xxx. Since it looks like test/CXX is intended to match the standard wording. Another reason is that it looks like we prefer to cite standard in the style of [module.context]p7 instead of 10.6-p7 since the number might change. And you mentioned it too.

some of the examples illustrate more than one bullet point

It doesn't matter since the example it self would live in a certain paragraph.

it makes it easier to find them for someone who is starting work on this area.

I feel like it would be helpful to put them under CXX since the tests under modules mixed many things about OC modules and Clang modules. The reason why some tests of the revision lives in test/Modules is might be hard to find the corresponding wording in the standard. But for things which is clearly corresponding to the standard, I always put them in test/CXX.

[iains]

In D113545#3601050, @ChuanqiXu wrote:

In D113545#3601031, @iains wrote:

I think it is helpful to collect the standard examples into one place (i.e. test/Modules) and name them for the standard version (i.e. cxx20-N-M-exO.cpp) .. because

• the details of the examples do change from one version of the standard to the next, because of changes in the normative text
• some of the examples illustrate more than one bullet point
• it makes it easier to find them for someone who is starting work on this area.

(not a big deal, but now we have some on one place and some in another - which is why I had missed that you already had one of the cases)

I prefer to put them under test/CXX/module/xxx. Since it looks like test/CXX is intended to match the standard wording. Another reason is that it looks like we prefer to cite standard in the style of [module.context]p7 instead of 10.6-p7 since the number might change. And you mentioned it too.

What I was referring to is that the content of the example. the bullet point(s) and even whether the example exists could change between c++20 and, say, c++23 ... but as noted this is not a big deal :)

[ChuanqiXu]

In D113545#3601069, @iains wrote:

In D113545#3601050, @ChuanqiXu wrote:

In D113545#3601031, @iains wrote:

I think it is helpful to collect the standard examples into one place (i.e. test/Modules) and name them for the standard version (i.e. cxx20-N-M-exO.cpp) .. because

• the details of the examples do change from one version of the standard to the next, because of changes in the normative text
• some of the examples illustrate more than one bullet point
• it makes it easier to find them for someone who is starting work on this area.

(not a big deal, but now we have some on one place and some in another - which is why I had missed that you already had one of the cases)

I prefer to put them under test/CXX/module/xxx. Since it looks like test/CXX is intended to match the standard wording. Another reason is that it looks like we prefer to cite standard in the style of [module.context]p7 instead of 10.6-p7 since the number might change. And you mentioned it too.

What I was referring to is that the content of the example. the bullet point(s) and even whether the example exists could change between c++20 and, say, c++23 ... but as noted this is not a big deal :)

Yeah, it shouldn't be a big problem : )

[rsmith]

A few comments, but they're all minor things or FIXMEs. I'm happy for this to land once they're addressed.

clang/include/clang/AST/DeclBase.h

229

clang/include/clang/Sema/Lookup.h

360–361

373–374

377

clang/lib/Sema/SemaLookup.cpp

1633–1664

Consider adding a Sema::hasAcceptableDefaultArgument to remove the duplicated dispatch here.

1795

Please rename With back to Within.

1895–1962

This function is assuming that any declaration in the ASTContext is in a translation unit on which we have an interface dependency. That's not going to be true in general (for example, using -fmodule-file you can load AST files on which there is no interface dependency, and clang-as-a-library users might even build an ASTContext containing the entire program), but seems good enough for now. Please add a FIXME (eg: "FIXME: Return false if we don't have an interface dependency on the translation unit containing D.").

1898–1907

The any_of here doesn't seem right to me for two reasons:

1. The rest of this function is answering the question, "is this particular declaration reachable?", not "is any declaration of this entity reachable?"
2. An entity should be reachable if any declaration of it is. Adding a declaration in a module map module should not cause other declarations to become less reachable.

1926

I don't think we should need the second check here: a declaration that's discarded in the GMF should be module-private, per your comment change on ModueOwnershipKind.

1947

It looks like this change is treating implementation partitions as being reachable only within the same module (see a few lines above: we say anything in the same module is reachable). That's the desirable behavior -- the only reason the standard allows implementation partitions to be reachable anywhere else is because the desirable behavior is harder to implement. So I'm happy with the current approach.

2076–2080

Yes, I'm fine with having FIXMEs for things that don't work yet -- so long as we don't regress things (particularly, so long as we don't regress module map module support, which some of our users are heavily relying on).

I agree that the wording here is not capturing the rules properly; I've mailed the CWG reflector and it sounds like Davis is going to fix that :)

3859

Hm, this might actually be right as-is: because we don't merge lookup results in the decl context lookup set if they come from different modules, we'll consider a friend once for each module that contains a friend declaration, and so we'll consider each class definition that contains a friend declaration here.

I think there's still something subtly wrong here: if there's a merged definition of D that is reachable, then the friend declaration should be considered. If you don't want to handle that here (it might be hard to come up with a testcase), please add a FIXME.

clang/lib/Serialization/ASTReaderDecl.cpp

626–627

Please don't include a default here. We want the compiler to tell us if a new enumerator is added and it isn't handled here.

[ChuanqiXu]

Address comments.

[ChuanqiXu]

In D113545#3616814, @rsmith wrote:

A few comments, but they're all minor things or FIXMEs. I'm happy for this to land once they're addressed.

Thanks for reviewing!

clang/lib/Sema/SemaLookup.cpp

2076–2080

Thanks! I believe it wouldn't be a regression.

clang/include/clang/AST/DeclBase.h

enum class ModuleOwnershipKind : unsigned {
     /// After serialization and deserialization, this will be converted
     /// to VisibleWhenImported.
     Visible,
 
     /// This declaration has an owning module, and is visible when that
     /// module is imported.
     VisibleWhenImported,
 
+    /// This declaration has an owning module, and is visible to lookups
+    /// that occurs within that module. And it is reachable in other module
+    /// when the owning module is transitively imported.
+    ReachableWhenImported,
+
     /// This declaration has an owning module, but is only visible to
     /// lookups that occur within that module.
+    /// The discarded declarations in global module fragment belongs
+    /// to this group too.
     ModulePrivate
   };
 
 protected:
   /// The next declaration within the same lexical
   /// DeclContext. These pointers form the linked list that is
   /// traversed via DeclContext's decls_begin()/decls_end().
   ///
-  /// The extra two bits are used for the ModuleOwnershipKind.
-  llvm::PointerIntPair<Decl *, 2, ModuleOwnershipKind> NextInContextAndBits;
+  /// The extra three bits are used for the ModuleOwnershipKind.
+  llvm::PointerIntPair<Decl *, 3, ModuleOwnershipKind> NextInContextAndBits;
 
 private:
   friend class DeclContext;
 
   struct MultipleDC {
     DeclContext *SemanticDC;
     DeclContext *LexicalDC;
   };
public:
   ///   void A::f1();        // isInExportDeclContext() == false
   ///
   ///   namespace B {
   ///      void f2();        // isInExportDeclContext() == false
   ///   }
   ///   export void B::f2(); // isInExportDeclContext() == true
   bool isInExportDeclContext() const;
 
+  bool isInvisibleOutsideTheOwningModule() const {
+    return getModuleOwnershipKind() > ModuleOwnershipKind::VisibleWhenImported;
+  }
+
+  /// FIXME: Implement discarding declarations actually in global module
+  /// fragment. See [module.global.frag]p3,4 for details.
+  bool isDiscardedInGlobalModuleFragment() const { return false; }
+
   /// Return true if this declaration has an attribute which acts as
   /// definition of the entity, such as 'alias' or 'ifunc'.
   bool hasDefiningAttr() const;
 
   /// Return this declaration's defining attribute if it has one.
   const Attr *getDefiningAttr() const;
 
 protected:
public:
   /// independent of whether the owning module is visible.
   /// Note: The declaration may be visible even if this returns \c false if the
   /// owning module is visible within the query context. This is a low-level
   /// helper function; most code should be calling Sema::isVisible() instead.
   bool isUnconditionallyVisible() const {
     return (int)getModuleOwnershipKind() <= (int)ModuleOwnershipKind::Visible;
   }
 
+  bool isReachable() const {
+    return (int)getModuleOwnershipKind() <=
+           (int)ModuleOwnershipKind::ReachableWhenImported;
+  }
+
   /// Set that this declaration is globally visible, even if it came from a
   /// module that is not visible.
   void setVisibleDespiteOwningModule() {
     if (!isUnconditionallyVisible())
       setModuleOwnershipKind(ModuleOwnershipKind::Visible);
   }
 
   /// Get the kind of module ownership for this declaration.

clang/include/clang/Basic/Module.h

public:
   }
 
   /// Does this Module scope describe a fragment of the global module within
   /// some C++ module.
   bool isGlobalModule() const { return Kind == GlobalModuleFragment; }
 
   bool isPrivateModule() const { return Kind == PrivateModuleFragment; }
 
+  bool isModuleMapModule() const { return Kind == ModuleMapModule; }
+
 private:
   /// The submodules of this module, indexed by name.
   std::vector<Module *> SubModules;
 
   /// A mapping from the submodule name to the index into the
   /// \c SubModules vector at which that submodule resides.
   llvm::StringMap<unsigned> SubModuleIndex;
 
public:
 
   /// Is this module a header unit.
   bool isHeaderUnit() const { return Kind == ModuleHeaderUnit; }
   // Is this a C++20 module interface or a partition.
   bool isInterfaceOrPartition() const {
     return Kind == ModuleInterfaceUnit || isModulePartition();
   }
 
+  bool isModuleInterfaceUnit() const {
+    return Kind == ModuleInterfaceUnit || Kind == ModulePartitionInterface;
+  }
+
   /// Get the primary module interface name from a partition.
   StringRef getPrimaryModuleInterfaceName() const {
     // Technically, global module fragment belongs to global module. And global
     // module has no name: [module.unit]p6:
     //   The global module has no name, no module interface unit, and is not
     //   introduced by any module-declaration.
     //
     // <global> is the default name showed in module map.

clang/include/clang/Sema/Lookup.h

public:
   /// Return the base paths structure that's associated with
   /// these results, or null if none is.
   CXXBasePaths *getBasePaths() const {
     return Paths;
   }
 
   /// Determine whether the given declaration is visible to the
   /// program.
-  static bool isVisible(Sema &SemaRef, NamedDecl *D) {
-    // If this declaration is not hidden, it's visible.
-    if (D->isUnconditionallyVisible())
-      return true;
+  static bool isVisible(Sema &SemaRef, NamedDecl *D);
 
-    // During template instantiation, we can refer to hidden declarations, if
-    // they were visible in any module along the path of instantiation.
-    return isVisibleSlow(SemaRef, D);
-  }
+  static bool isReachable(Sema &SemaRef, NamedDecl *D);
+
+  static bool isAcceptable(Sema &SemaRef, NamedDecl *D,
+                           Sema::AcceptableKind Kind) {
+    return Kind == Sema::AcceptableKind::Visible ? isVisible(SemaRef, D)
+                                                 : isReachable(SemaRef, D);
+  }
+
+  /// Determine whether this lookup is permitted to see the declaration.
+  /// Note that a reachable but not visible declaration inhabiting a namespace
+  /// is not allowed to be seen during name lookup.
+  ///
+  /// For example:
+  /// ```
+  /// // m.cppm
+  /// export module m;
+  /// struct reachable { int v; }
+  /// export auto func() { return reachable{43}; }
+  /// // Use.cpp
+  /// import m;
+  /// auto Use() {
+  ///   // Not valid. We couldn't see reachable here.
+  ///   // So isAvailableForLookup would return false when we look
+  ///   up 'reachable' here.
+  ///   // return reachable(43).v;
+  ///   // Valid. The field name 'v' is allowed during name lookup.
+  ///   // So isAvailableForLookup would return true when we look up 'v' here.
+  ///   return func().v;
+  /// }
+  /// ```
+  static bool isAvailableForLookup(Sema &SemaRef, NamedDecl *ND);
 
   /// Retrieve the accepted (re)declaration of the given declaration,
   /// if there is one.
   NamedDecl *getAcceptableDecl(NamedDecl *D) const {
     if (!D->isInIdentifierNamespace(IDNS))
       return nullptr;
 
-    if (isVisible(getSema(), D) || isHiddenDeclarationVisible(D))
+    if (isAvailableForLookup(getSema(), D) || isHiddenDeclarationVisible(D))
       return D;
 
     return getAcceptableDeclSlow(D);
   }
 
 private:
-  static bool isVisibleSlow(Sema &SemaRef, NamedDecl *D);
+  static bool isAcceptableSlow(Sema &SemaRef, NamedDecl *D,
+                               Sema::AcceptableKind Kind);
+  static bool isReachableSlow(Sema &SemaRef, NamedDecl *D);
   NamedDecl *getAcceptableDeclSlow(NamedDecl *D) const;
 
 public:
   /// Returns the identifier namespace mask for this lookup.
   unsigned getIdentifierNamespace() const {
     return IDNS;
   }
 

clang/include/clang/Sema/Sema.h

class Sema final {
   ///Source of additional semantic information.
   ExternalSemaSource *ExternalSource;
 
   ///Whether Sema has generated a multiplexer and has to delete it.
   bool isMultiplexExternalSource;
 
   static bool mightHaveNonExternalLinkage(const DeclaratorDecl *FD);
 
-  bool isVisibleSlow(const NamedDecl *D);
-
   /// Determine whether two declarations should be linked together, given that
   /// the old declaration might not be visible and the new declaration might
   /// not have external linkage.
   bool shouldLinkPossiblyHiddenDecl(const NamedDecl *Old,
                                     const NamedDecl *New) {
     if (isVisible(Old))
      return true;
     // See comment in below overload for why it's safe to compute the linkage
enum class CompleteTypeKind {
     /// sizeless built-in types.
     AcceptSizeless,
 
     // FIXME: Eventually we should flip the default to Normal and opt in
     // to AcceptSizeless rather than opt out of it.
     Default = AcceptSizeless
   };
 
+  enum class AcceptableKind { Visible, Reachable };
+
 private:
   /// Methods for marking which expressions involve dereferencing a pointer
   /// marked with the 'noderef' attribute. Expressions are checked bottom up as
   /// they are parsed, meaning that a noderef pointer may not be accessed. For
   /// example, in `&*p` where `p` is a noderef pointer, we will first parse the
   /// `*p`, but need to check that `address of` is called on it. This requires
   /// keeping a container of all pending expressions and checking if the address
   /// of them are eventually taken.
private:
   clang::Module *GlobalModuleFragment = nullptr;
 
   /// The modules we imported directly.
   llvm::SmallPtrSet<clang::Module *, 8> DirectModuleImports;
 
   /// Namespace definitions that we will export when they finish.
   llvm::SmallPtrSet<const NamespaceDecl*, 8> DeferredExportedNamespaces;
 
-  /// Get the module unit whose scope we are currently within.
-  Module *getCurrentModule() const {
-    return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
-  }
-
   /// Helper function to judge if we are in module purview.
   /// Return false if we are not in a module.
   bool isCurrentModulePurview() const {
     return getCurrentModule() ? getCurrentModule()->isModulePurview() : false;
   }
 
   /// Enter the scope of the global module.
   Module *PushGlobalModuleFragment(SourceLocation BeginLoc, bool IsImplicit);
   /// Leave the scope of the global module.
   void PopGlobalModuleFragment();
 
   VisibleModuleSet VisibleModules;
 
   /// 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:
+  /// Get the module unit whose scope we are currently within.
+  Module *getCurrentModule() const {
+    return ModuleScopes.empty() ? nullptr : ModuleScopes.back().Module;
+  }
+
   /// Get the module owning an entity.
   Module *getOwningModule(const Decl *Entity) {
     return Entity->getOwningModule();
   }
 
   bool isModuleDirectlyImported(const Module *M) {
     return DirectModuleImports.contains(M);
   }
 
   /// Make a merged definition of an existing hidden definition \p ND
   /// visible at the specified location.
   void makeMergedDefinitionVisible(NamedDecl *ND);
 
   bool isModuleVisible(const Module *M, bool ModulePrivate = false);
 
   // When loading a non-modular PCH files, this is used to restore module
   // visibility.
   void makeModuleVisible(Module *Mod, SourceLocation ImportLoc) {
     VisibleModules.setVisible(Mod, ImportLoc);
   }
 
   /// Determine whether a declaration is visible to name lookup.
   bool isVisible(const NamedDecl *D) {
-    return D->isUnconditionallyVisible() || isVisibleSlow(D);
+    return D->isUnconditionallyVisible() ||
+           isAcceptableSlow(D, AcceptableKind::Visible);
+  }
+
+  /// Determine whether a declaration is reachable.
+  bool isReachable(const NamedDecl *D) {
+    // All visible declarations are reachable.
+    return D->isUnconditionallyVisible() ||
+           isAcceptableSlow(D, AcceptableKind::Reachable);
+  }
+
+  /// Determine whether a declaration is acceptable (visible/reachable).
+  bool isAcceptable(const NamedDecl *D, AcceptableKind Kind) {
+    return Kind == AcceptableKind::Visible ? isVisible(D) : isReachable(D);
   }
 
   /// Determine whether any declaration of an entity is visible.
   bool
   hasVisibleDeclaration(const NamedDecl *D,
                         llvm::SmallVectorImpl<Module *> *Modules = nullptr) {
     return isVisible(D) || hasVisibleDeclarationSlow(D, Modules);
   }
+
   bool hasVisibleDeclarationSlow(const NamedDecl *D,
                                  llvm::SmallVectorImpl<Module *> *Modules);
+  /// Determine whether any declaration of an entity is reachable.
+  bool
+  hasReachableDeclaration(const NamedDecl *D,
+                          llvm::SmallVectorImpl<Module *> *Modules = nullptr) {
+    return isReachable(D) || hasReachableDeclarationSlow(D, Modules);
+  }
+  bool hasReachableDeclarationSlow(
+      const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
 
   bool hasVisibleMergedDefinition(NamedDecl *Def);
   bool hasMergedDefinitionInCurrentModule(NamedDecl *Def);
 
   /// Determine if \p D and \p Suggested have a structurally compatible
   /// layout as described in C11 6.2.7/1.
   bool hasStructuralCompatLayout(Decl *D, Decl *Suggested);
 
   /// Determine if \p D has a visible definition. If not, suggest a declaration
   /// that should be made visible to expose the definition.
   bool hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested,
                             bool OnlyNeedComplete = false);
   bool hasVisibleDefinition(const NamedDecl *D) {
     NamedDecl *Hidden;
     return hasVisibleDefinition(const_cast<NamedDecl*>(D), &Hidden);
   }
 
+  /// Determine if \p D has a reachable definition. If not, suggest a
+  /// declaration that should be made reachable to expose the definition.
+  bool hasReachableDefinition(NamedDecl *D, NamedDecl **Suggested,
+                              bool OnlyNeedComplete = false);
+  bool hasReachableDefinition(NamedDecl *D) {
+    NamedDecl *Hidden;
+    return hasReachableDefinition(D, &Hidden);
+  }
+
+  bool hasAcceptableDefinition(NamedDecl *D, NamedDecl **Suggested,
+                               AcceptableKind Kind,
+                               bool OnlyNeedComplete = false);
+  bool hasAcceptableDefinition(NamedDecl *D, AcceptableKind Kind) {
+    NamedDecl *Hidden;
+    return hasAcceptableDefinition(D, &Hidden, Kind);
+  }
+
   /// Determine if the template parameter \p D has a visible default argument.
   bool
   hasVisibleDefaultArgument(const NamedDecl *D,
                             llvm::SmallVectorImpl<Module *> *Modules = nullptr);
+  /// Determine if the template parameter \p D has a reachable default argument.
+  bool hasReachableDefaultArgument(
+      const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
+  /// Determine if the template parameter \p D has a reachable default argument.
+  bool hasAcceptableDefaultArgument(const NamedDecl *D,
+                                    llvm::SmallVectorImpl<Module *> *Modules,
+                                    Sema::AcceptableKind Kind);
 
   /// Determine if there is a visible declaration of \p D that is an explicit
   /// specialization declaration for a specialization of a template. (For a
   /// member specialization, use hasVisibleMemberSpecialization.)
   bool hasVisibleExplicitSpecialization(
       const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
+  /// Determine if there is a reachable declaration of \p D that is an explicit
+  /// specialization declaration for a specialization of a template. (For a
+  /// member specialization, use hasReachableMemberSpecialization.)
+  bool hasReachableExplicitSpecialization(
+      const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
 
   /// Determine if there is a visible declaration of \p D that is a member
   /// specialization declaration (as opposed to an instantiated declaration).
   bool hasVisibleMemberSpecialization(
       const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
+  /// Determine if there is a reachable declaration of \p D that is a member
+  /// specialization declaration (as opposed to an instantiated declaration).
+  bool hasReachableMemberSpecialization(
+      const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules = nullptr);
 
   /// Determine if \p A and \p B are equivalent internal linkage declarations
   /// from different modules, and thus an ambiguity error can be downgraded to
   /// an extension warning.
   bool isEquivalentInternalLinkageDeclaration(const NamedDecl *A,
                                               const NamedDecl *B);
   void diagnoseEquivalentInternalLinkageDeclarations(
       SourceLocation Loc, const NamedDecl *D,
public:
 
   Decl *ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc,
                              SourceLocation LBraceLoc);
   Decl *ActOnFinishExportDecl(Scope *S, Decl *ExportDecl,
                               SourceLocation RBraceLoc);
 
   /// We've found a use of a templated declaration that would trigger an
   /// implicit instantiation. Check that any relevant explicit specializations
-  /// and partial specializations are visible, and diagnose if not.
+  /// and partial specializations are visible/reachable, and diagnose if not.
   void checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec);
+  void checkSpecializationReachability(SourceLocation Loc, NamedDecl *Spec);
 
   /// Retrieve a suitable printing policy for diagnostics.
   PrintingPolicy getPrintingPolicy() const {
     return getPrintingPolicy(Context, PP);
   }
 
   /// Retrieve a suitable printing policy for diagnostics.
   static PrintingPolicy getPrintingPolicy(const ASTContext &Ctx,

clang/lib/AST/Decl.cpp

if (auto *M = D->getOwningModule())
     return M->isModulePurview();
   return false;
 }
 
 static bool isExportedFromModuleInterfaceUnit(const NamedDecl *D) {
   // FIXME: Handle isModulePrivate.
   switch (D->getModuleOwnershipKind()) {
   case Decl::ModuleOwnershipKind::Unowned:
+  case Decl::ModuleOwnershipKind::ReachableWhenImported:
   case Decl::ModuleOwnershipKind::ModulePrivate:
     return false;
   case Decl::ModuleOwnershipKind::Visible:
   case Decl::ModuleOwnershipKind::VisibleWhenImported:
     return isInModulePurview(D);
   }
   llvm_unreachable("unexpected module ownership kind");
 }

clang/lib/Sema/SemaCXXScopeSpec.cpp

if (EnteringContext) {
           // class template partial specialization.
           if (ClassTemplatePartialSpecializationDecl *PartialSpec
                 = ClassTemplate->findPartialSpecialization(ContextType)) {
             // A declaration of the partial specialization must be visible.
             // We can always recover here, because this only happens when we're
             // entering the context, and that can't happen in a SFINAE context.
             assert(!isSFINAEContext() &&
                    "partial specialization scope specifier in SFINAE context?");
-            if (!hasVisibleDeclaration(PartialSpec))
+            if (!hasReachableDefinition(PartialSpec))
               diagnoseMissingImport(SS.getLastQualifierNameLoc(), PartialSpec,
                                     MissingImportKind::PartialSpecialization,
                                     /*Recover*/true);
             return PartialSpec;
           }
         }
       } else if (const RecordType *RecordT = NNSType->getAs<RecordType>()) {
         // The nested name specifier refers to a member of a class template.

 /// Require that the EnumDecl is completed with its enumerators defined or
 /// instantiated. SS, if provided, is the ScopeRef parsed.
 ///
 bool Sema::RequireCompleteEnumDecl(EnumDecl *EnumD, SourceLocation L,
                                    CXXScopeSpec *SS) {
   if (EnumD->isCompleteDefinition()) {
     // If we know about the definition but it is not visible, complain.
     NamedDecl *SuggestedDef = nullptr;
-    if (!hasVisibleDefinition(EnumD, &SuggestedDef,
-                              /*OnlyNeedComplete*/false)) {
+    if (!hasReachableDefinition(EnumD, &SuggestedDef,
+                                /*OnlyNeedComplete*/ false)) {
       // If the user is going to see an error here, recover by making the
       // definition visible.
       bool TreatAsComplete = !isSFINAEContext();
       diagnoseMissingImport(L, SuggestedDef, MissingImportKind::Definition,
                             /*Recover*/ TreatAsComplete);
       return !TreatAsComplete;
     }
     return false;

clang/lib/Sema/SemaDeclCXX.cpp

Decl *Sema::ActOnStartLinkageSpecification(Scope *S, SourceLocation ExternLoc,
   ///   - appears within a linkage-specification,
   ///   it is attached to the global module.
   ///
   /// If the declaration is already in global module fragment, we don't
   /// need to attach it again.
   if (getLangOpts().CPlusPlusModules && isCurrentModulePurview()) {
     Module *GlobalModule =
         PushGlobalModuleFragment(ExternLoc, /*IsImplicit=*/true);
-    D->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);
+    /// According to [module.reach]p3.2,
+    /// The declaration in global module fragment is reachable if it is not
+    /// discarded. And the discarded declaration should be deleted. So it
+    /// doesn't matter mark the declaration in global module fragment as
+    /// reachable here.
+    D->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ReachableWhenImported);
     D->setLocalOwningModule(GlobalModule);
   }
 
   CurContext->addDecl(D);
   PushDeclContext(S, D);
   return D;
 }
 

clang/lib/Sema/SemaExpr.cpp

void Sema::MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func,
   // C++14 [temp.expl.spec]p6:
   //   If a template [...] is explicitly specialized then that specialization
   //   shall be declared before the first use of that specialization that would
   //   cause an implicit instantiation to take place, in every translation unit
   //   in which such a use occurs
   if (NeedDefinition &&
       (Func->getTemplateSpecializationKind() != TSK_Undeclared ||
        Func->getMemberSpecializationInfo()))
-    checkSpecializationVisibility(Loc, Func);
+    checkSpecializationReachability(Loc, Func);
 
   if (getLangOpts().CUDA)
     CheckCUDACall(Loc, Func);
 
   if (getLangOpts().SYCLIsDevice)
     checkSYCLDeviceFunction(Loc, Func);
 
   // If we need a definition, try to create one.

clang/lib/Sema/SemaLookup.cpp

 
 bool Sema::hasMergedDefinitionInCurrentModule(NamedDecl *Def) {
   for (const Module *Merged : Context.getModulesWithMergedDefinition(Def))
     if (isUsableModule(Merged))
       return true;
   return false;
 }
 
-template<typename ParmDecl>
+template <typename ParmDecl>
 static bool
-hasVisibleDefaultArgument(Sema &S, const ParmDecl *D,
-                          llvm::SmallVectorImpl<Module *> *Modules) {
+hasAcceptableDefaultArgument(Sema &S, const ParmDecl *D,
+                             llvm::SmallVectorImpl<Module *> *Modules,
+                             Sema::AcceptableKind Kind) {
   if (!D->hasDefaultArgument())
     return false;
 
   while (D) {
     auto &DefaultArg = D->getDefaultArgStorage();
-    if (!DefaultArg.isInherited() && S.isVisible(D))
+    if (!DefaultArg.isInherited() && S.isAcceptable(D, Kind))
       return true;
 
     if (!DefaultArg.isInherited() && Modules) {
       auto *NonConstD = const_cast<ParmDecl*>(D);
       Modules->push_back(S.getOwningModule(NonConstD));
     }
 
     // If there was a previous default argument, maybe its parameter is visible.
     D = DefaultArg.getInheritedFrom();
   }
   return false;
 }
 
-bool Sema::hasVisibleDefaultArgument(const NamedDecl *D,
-                                     llvm::SmallVectorImpl<Module *> *Modules) {
+bool Sema::hasAcceptableDefaultArgument(
+    const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules,
+    Sema::AcceptableKind Kind) {
   if (auto *P = dyn_cast<TemplateTypeParmDecl>(D))
-    return ::hasVisibleDefaultArgument(*this, P, Modules);
+    return ::hasAcceptableDefaultArgument(*this, P, Modules, Kind);
+
   if (auto *P = dyn_cast<NonTypeTemplateParmDecl>(D))
-    return ::hasVisibleDefaultArgument(*this, P, Modules);
-  return ::hasVisibleDefaultArgument(*this, cast<TemplateTemplateParmDecl>(D),
-                                     Modules);
+    return ::hasAcceptableDefaultArgument(*this, P, Modules, Kind);
+
+  return ::hasAcceptableDefaultArgument(
+      *this, cast<TemplateTemplateParmDecl>(D), Modules, Kind);
+}
+
+bool Sema::hasVisibleDefaultArgument(const NamedDecl *D,
+                                     llvm::SmallVectorImpl<Module *> *Modules) {
+  return hasAcceptableDefaultArgument(D, Modules,
+                                      Sema::AcceptableKind::Visible);
+}
+
+bool Sema::hasReachableDefaultArgument(
+    const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
+  return hasAcceptableDefaultArgument(D, Modules,
+                                      Sema::AcceptableKind::Reachable);
 }
 
-template<typename Filter>
-static bool hasVisibleDeclarationImpl(Sema &S, const NamedDecl *D,
-                                      llvm::SmallVectorImpl<Module *> *Modules,
-                                      Filter F) {
+template <typename Filter>
+static bool
+hasAcceptableDeclarationImpl(Sema &S, const NamedDecl *D,
+                             llvm::SmallVectorImpl<Module *> *Modules, Filter F,
+                             Sema::AcceptableKind Kind) {
   bool HasFilteredRedecls = false;
 
   for (auto *Redecl : D->redecls()) {
     auto *R = cast<NamedDecl>(Redecl);
     if (!F(R))
       continue;
 
-    if (S.isVisible(R))
+    if (S.isAcceptable(R, Kind))
       return true;
 
     HasFilteredRedecls = true;
 
     if (Modules)
       Modules->push_back(R->getOwningModule());
   }
 
   // Only return false if there is at least one redecl that is not filtered out.
   if (HasFilteredRedecls)
     return false;
 
   return true;
 }
 
-bool Sema::hasVisibleExplicitSpecialization(
-    const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
-  return hasVisibleDeclarationImpl(*this, D, Modules, [](const NamedDecl *D) {
+static bool
+hasAcceptableExplicitSpecialization(Sema &S, const NamedDecl *D,
+                                    llvm::SmallVectorImpl<Module *> *Modules,
+                                    Sema::AcceptableKind Kind) {
+  return hasAcceptableDeclarationImpl(
+      S, D, Modules,
+      [](const NamedDecl *D) {
         if (auto *RD = dyn_cast<CXXRecordDecl>(D))
-      return RD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
+          return RD->getTemplateSpecializationKind() ==
+                 TSK_ExplicitSpecialization;
         if (auto *FD = dyn_cast<FunctionDecl>(D))
-      return FD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
+          return FD->getTemplateSpecializationKind() ==
+                 TSK_ExplicitSpecialization;
         if (auto *VD = dyn_cast<VarDecl>(D))
-      return VD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization;
+          return VD->getTemplateSpecializationKind() ==
+                 TSK_ExplicitSpecialization;
         llvm_unreachable("unknown explicit specialization kind");
-  });
+      },
+      Kind);
 }
 
-bool Sema::hasVisibleMemberSpecialization(
+bool Sema::hasVisibleExplicitSpecialization(
     const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
+  return ::hasAcceptableExplicitSpecialization(*this, D, Modules,
+                                               Sema::AcceptableKind::Visible);
+}
+
+bool Sema::hasReachableExplicitSpecialization(
+    const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
+  return ::hasAcceptableExplicitSpecialization(*this, D, Modules,
+                                               Sema::AcceptableKind::Reachable);
+}
+
+static bool
+hasAcceptableMemberSpecialization(Sema &S, const NamedDecl *D,
+                                  llvm::SmallVectorImpl<Module *> *Modules,
+                                  Sema::AcceptableKind Kind) {
   assert(isa<CXXRecordDecl>(D->getDeclContext()) &&
          "not a member specialization");
-  return hasVisibleDeclarationImpl(*this, D, Modules, [](const NamedDecl *D) {
-    // If the specialization is declared at namespace scope, then it's a member
-    // specialization declaration. If it's lexically inside the class
+  return hasAcceptableDeclarationImpl(
+      S, D, Modules,
+      [](const NamedDecl *D) {
+        // If the specialization is declared at namespace scope, then it's a
+        // member specialization declaration. If it's lexically inside the class
         // definition then it was instantiated.
         //
-    // FIXME: This is a hack. There should be a better way to determine this.
+        // FIXME: This is a hack. There should be a better way to determine
+        // this.
         // FIXME: What about MS-style explicit specializations declared within a
         //        class definition?
         return D->getLexicalDeclContext()->isFileContext();
-  });
+      },
+      Kind);
 }
 
-/// Determine whether a declaration is visible to name lookup.
+bool Sema::hasVisibleMemberSpecialization(
+    const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
+  return hasAcceptableMemberSpecialization(*this, D, Modules,
+                                           Sema::AcceptableKind::Visible);
+}
+
+bool Sema::hasReachableMemberSpecialization(
+    const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
+  return hasAcceptableMemberSpecialization(*this, D, Modules,
+                                           Sema::AcceptableKind::Reachable);
+}
+
+/// Determine whether a declaration is acceptable to name lookup.
 ///
-/// This routine determines whether the declaration D is visible in the current
-/// lookup context, taking into account the current template instantiation
-/// stack. During template instantiation, a declaration is visible if it is
-/// visible from a module containing any entity on the template instantiation
-/// path (by instantiating a template, you allow it to see the declarations that
-/// your module can see, including those later on in your module).
-bool LookupResult::isVisibleSlow(Sema &SemaRef, NamedDecl *D) {
+/// This routine determines whether the declaration D is acceptable in the
+/// current lookup context, taking into account the current template
+/// instantiation stack. During template instantiation, a declaration is
+/// acceptable if it is acceptable from a module containing any entity on the
+/// template instantiation path (by instantiating a template, you allow it to
+/// see the declarations that your module can see, including those later on in
+/// your module).
+bool LookupResult::isAcceptableSlow(Sema &SemaRef, NamedDecl *D,
+                                    Sema::AcceptableKind Kind) {
   assert(!D->isUnconditionallyVisible() &&
          "should not call this: not in slow case");
 
   Module *DeclModule = SemaRef.getOwningModule(D);
   assert(DeclModule && "hidden decl has no owning module");
 
-  if (SemaRef.isModuleVisible(DeclModule, D->isModulePrivate()))
-    // If the owning module is visible, the decl is visible.
+  // If the owning module is visible, the decl is acceptable.
+  if (SemaRef.isModuleVisible(DeclModule,
+                              D->isInvisibleOutsideTheOwningModule()))
     return true;
 
   // Determine whether a decl context is a file context for the purpose of
-  // visibility. This looks through some (export and linkage spec) transparent
-  // contexts, but not others (enums).
+  // visibility/reachability. This looks through some (export and linkage spec)
+  // transparent contexts, but not others (enums).
   auto IsEffectivelyFileContext = [](const DeclContext *DC) {
     return DC->isFileContext() || isa<LinkageSpecDecl>(DC) ||
            isa<ExportDecl>(DC);
   };
 
   // If this declaration is not at namespace scope
-  // then it is visible if its lexical parent has a visible definition.
+  // then it is acceptable if its lexical parent has a acceptable definition.
   DeclContext *DC = D->getLexicalDeclContext();
   if (DC && !IsEffectivelyFileContext(DC)) {
     // For a parameter, check whether our current template declaration's
-    // lexical context is visible, not whether there's some other visible
+    // lexical context is acceptable, not whether there's some other acceptable
     // definition of it, because parameters aren't "within" the definition.
     //
-    // In C++ we need to check for a visible definition due to ODR merging,
+    // In C++ we need to check for a acceptable definition due to ODR merging,
     // and in C we must not because each declaration of a function gets its own
     // set of declarations for tags in prototype scope.
-    bool VisibleWithinParent;
+    bool AcceptableWithinParent;
     if (D->isTemplateParameter()) {
       bool SearchDefinitions = true;
       if (const auto *DCD = dyn_cast<Decl>(DC)) {
         if (const auto *TD = DCD->getDescribedTemplate()) {
           TemplateParameterList *TPL = TD->getTemplateParameters();
           auto Index = getDepthAndIndex(D).second;
           SearchDefinitions = Index >= TPL->size() || TPL->getParam(Index) != D;
         }
       }
       if (SearchDefinitions)
-        VisibleWithinParent = SemaRef.hasVisibleDefinition(cast<NamedDecl>(DC));
+        AcceptableWithinParent =
+            SemaRef.hasAcceptableDefinition(cast<NamedDecl>(DC), Kind);
       else
-        VisibleWithinParent = isVisible(SemaRef, cast<NamedDecl>(DC));
+        AcceptableWithinParent =
+            isAcceptable(SemaRef, cast<NamedDecl>(DC), Kind);
     } else if (isa<ParmVarDecl>(D) ||
                (isa<FunctionDecl>(DC) && !SemaRef.getLangOpts().CPlusPlus))
-      VisibleWithinParent = isVisible(SemaRef, cast<NamedDecl>(DC));
+      AcceptableWithinParent = isAcceptable(SemaRef, cast<NamedDecl>(DC), Kind);
     else if (D->isModulePrivate()) {
-      // A module-private declaration is only visible if an enclosing lexical
+      // A module-private declaration is only acceptable if an enclosing lexical
       // parent was merged with another definition in the current module.
-      VisibleWithinParent = false;
+      AcceptableWithinParent = false;
       do {
         if (SemaRef.hasMergedDefinitionInCurrentModule(cast<NamedDecl>(DC))) {
-          VisibleWithinParent = true;
+          AcceptableWithinParent = true;
           break;
         }
         DC = DC->getLexicalParent();
       } while (!IsEffectivelyFileContext(DC));
     } else {
-      VisibleWithinParent = SemaRef.hasVisibleDefinition(cast<NamedDecl>(DC));
+      AcceptableWithinParent =
+          SemaRef.hasAcceptableDefinition(cast<NamedDecl>(DC), Kind);
     }
 
-    if (VisibleWithinParent && SemaRef.CodeSynthesisContexts.empty() &&
+    if (AcceptableWithinParent && SemaRef.CodeSynthesisContexts.empty() &&
+        Kind == Sema::AcceptableKind::Visible &&
         // FIXME: Do something better in this case.
         !SemaRef.getLangOpts().ModulesLocalVisibility) {
       // Cache the fact that this declaration is implicitly visible because
       // its parent has a visible definition.
       D->setVisibleDespiteOwningModule();
     }
-    return VisibleWithinParent;
+    return AcceptableWithinParent;
   }
 
+  if (Kind == Sema::AcceptableKind::Visible)
     return false;
+
+  assert(Kind == Sema::AcceptableKind::Reachable &&
+         "Additional Sema::AcceptableKind?");
+  return isReachableSlow(SemaRef, D);
 }
 
 bool Sema::isModuleVisible(const Module *M, bool ModulePrivate) {
+  // [module.global.frag]p2:
+  // A global-module-fragment specifies the contents of the global module
+  // fragment for a module unit. The global module fragment can be used to
+  // provide declarations that are attached to the global module and usable
+  // within the module unit.
+  //
+  // Global module fragment is special. Global Module fragment is only usable
+  // within the module unit it got defined [module.global.frag]p2. So here we
+  // check if the Module is the global module fragment in current translation
+  // unit.
+  if (M->isGlobalModule() && M != this->GlobalModuleFragment)
+    return false;
+
   // The module might be ordinarily visible. For a module-private query, that
   // means it is part of the current module.
   if (ModulePrivate && isUsableModule(M))
     return true;
 
   // For a query which is not module-private, that means it is in our visible
   // module set.
   if (!ModulePrivate && VisibleModules.isVisible(M))
if (ModulePrivate)
     return false;
 
   // Check whether M is transitively exported to an import of the lookup set.
   return llvm::any_of(LookupModules, [&](const Module *LookupM) {
     return LookupM->isModuleVisible(M);
   });
 }
 
-bool Sema::isVisibleSlow(const NamedDecl *D) {
-  return LookupResult::isVisible(*this, const_cast<NamedDecl*>(D));
+// FIXME: Return false directly if we don't have an interface dependency on the
+// translation unit containing D.
+bool LookupResult::isReachableSlow(Sema &SemaRef, NamedDecl *D) {
+  assert(!isVisible(SemaRef, D) && "Shouldn't call the slow case.\n");
+
+  Module *DeclModule = SemaRef.getOwningModule(D);
+  assert(DeclModule && "hidden decl has no owning module");
+
+  // Entities in module map modules are reachable only if they're visible.
+  if (DeclModule->isModuleMapModule())
+    return false;
+
+  // If D comes from a module and SemaRef doesn't own a module, it implies D
+  // comes from another TU. In case SemaRef owns a module, we could judge if D
+  // comes from another TU by comparing the module unit.
+  //
+  // FIXME: It would look better if we have direct method to judge whether D is
+  // in another TU.
+  if (SemaRef.getCurrentModule() &&
+      SemaRef.getCurrentModule()->getTopLevelModule() ==
+          DeclModule->getTopLevelModule())
+    return true;
+
+  // [module.reach]/p3:
+  // A declaration D is reachable from a point P if:
+  // ...
+  // - D is not discarded ([module.global.frag]), appears in a translation unit
+  //   that is reachable from P, and does not appear within a private module
+  //   fragment.
+  //
+  // A declaration that's discarded in the GMF should be module-private.
+  if (D->isModulePrivate())
+    return false;
+
+  // [module.reach]/p1
+  //   A translation unit U is necessarily reachable from a point P if U is a
+  //   module interface unit on which the translation unit containing P has an
+  //   interface dependency, or the translation unit containing P imports U, in
+  //   either case prior to P ([module.import]).
+  //
+  // [module.import]/p10
+  //   A translation unit has an interface dependency on a translation unit U if
+  //   it contains a declaration (possibly a module-declaration) that imports U
+  //   or if it has an interface dependency on a translation unit that has an
+  //   interface dependency on U.
+  //
+  // So we could conclude the module unit U is necessarily reachable if:
+  // (1) The module unit U is module interface unit.
+  // (2) The current unit has an interface dependency on the module unit U.
+  //
+  // Here we only check for the first condition. Since we couldn't see
+  // DeclModule if it isn't (transitively) imported.
+  if (DeclModule->getTopLevelModule()->isModuleInterfaceUnit())
+    return true;
+
+  // [module.reach]/p2
+  //   Additional translation units on
+  //   which the point within the program has an interface dependency may be
+  //   considered reachable, but it is unspecified which are and under what
+  //   circumstances.
+  //
+  // The decision here is to treat all additional tranditional units as
+  // unreachable.
+  return false;
+}
+
+bool Sema::isAcceptableSlow(const NamedDecl *D, Sema::AcceptableKind Kind) {
+  return LookupResult::isAcceptable(*this, const_cast<NamedDecl *>(D), Kind);
 }
 
 bool Sema::shouldLinkPossiblyHiddenDecl(LookupResult &R, const NamedDecl *New) {
   // FIXME: If there are both visible and hidden declarations, we need to take
   // into account whether redeclaration is possible. Example:
   //
   // Non-imported module:
   //   int f(T);        // #1

 /// This routine determines whether the declaration D is visible in the current
 /// module, with the current imports. If not, it checks whether any
 /// redeclaration of D is visible, and if so, returns that declaration.
 ///
 /// \returns D, or a visible previous declaration of D, whichever is more recent
 /// and visible. If no declaration of D is visible, returns null.
 static NamedDecl *findAcceptableDecl(Sema &SemaRef, NamedDecl *D,
                                      unsigned IDNS) {
-  assert(!LookupResult::isVisible(SemaRef, D) && "not in slow case");
+  assert(!LookupResult::isAvailableForLookup(SemaRef, D) && "not in slow case");
 
   for (auto RD : D->redecls()) {
     // Don't bother with extra checks if we already know this one isn't visible.
     if (RD == D)
       continue;
 
     auto ND = cast<NamedDecl>(RD);
     // FIXME: This is wrong in the case where the previous declaration is not
     // visible in the same scope as D. This needs to be done much more
     // carefully.
     if (ND->isInIdentifierNamespace(IDNS) &&
-        LookupResult::isVisible(SemaRef, ND))
+        LookupResult::isAvailableForLookup(SemaRef, ND))
       return ND;
   }
 
   return nullptr;
 }
 
 bool Sema::hasVisibleDeclarationSlow(const NamedDecl *D,
                                      llvm::SmallVectorImpl<Module *> *Modules) {
   assert(!isVisible(D) && "not in slow case");
-  return hasVisibleDeclarationImpl(*this, D, Modules,
-                                   [](const NamedDecl *) { return true; });
+  return hasAcceptableDeclarationImpl(
+      *this, D, Modules, [](const NamedDecl *) { return true; },
+      Sema::AcceptableKind::Visible);
+}
+
+bool Sema::hasReachableDeclarationSlow(
+    const NamedDecl *D, llvm::SmallVectorImpl<Module *> *Modules) {
+  assert(!isReachable(D) && "not in slow case");
+  return hasAcceptableDeclarationImpl(
+      *this, D, Modules, [](const NamedDecl *) { return true; },
+      Sema::AcceptableKind::Reachable);
 }
 
 NamedDecl *LookupResult::getAcceptableDeclSlow(NamedDecl *D) const {
   if (auto *ND = dyn_cast<NamespaceDecl>(D)) {
     // Namespaces are a bit of a special case: we expect there to be a lot of
     // redeclarations of some namespaces, all declarations of a namespace are
     // essentially interchangeable, all declarations are found by name lookup
     // if any is, and namespaces are never looked up during template
     // instantiation. So we benefit from caching the check in this case, and
     // it is correct to do so.
     auto *Key = ND->getCanonicalDecl();
     if (auto *Acceptable = getSema().VisibleNamespaceCache.lookup(Key))
       return Acceptable;
     auto *Acceptable = isVisible(getSema(), Key)
                            ? Key
                            : findAcceptableDecl(getSema(), Key, IDNS);
     if (Acceptable)
       getSema().VisibleNamespaceCache.insert(std::make_pair(Key, Acceptable));
     return Acceptable;
   }
 
   return findAcceptableDecl(getSema(), D, IDNS);
 }
 
+bool LookupResult::isVisible(Sema &SemaRef, NamedDecl *D) {
+  // If this declaration is already visible, return it directly.
+  if (D->isUnconditionallyVisible())
+    return true;
+
+  // During template instantiation, we can refer to hidden declarations, if
+  // they were visible in any module along the path of instantiation.
+  return isAcceptableSlow(SemaRef, D, Sema::AcceptableKind::Visible);
+}
+
+bool LookupResult::isReachable(Sema &SemaRef, NamedDecl *D) {
+  if (D->isUnconditionallyVisible())
+    return true;
+
+  return isAcceptableSlow(SemaRef, D, Sema::AcceptableKind::Reachable);
+}
+
+bool LookupResult::isAvailableForLookup(Sema &SemaRef, NamedDecl *ND) {
+  // We should check the visibility at the callsite already.
+  if (isVisible(SemaRef, ND))
+    return true;
+
+  auto *DC = ND->getDeclContext();
+  // If ND is not visible and it is at namespace scope, it shouldn't be found
+  // by name lookup.
+  if (DC->isFileContext())
+    return false;
+
+  // [module.interface]p7
+  // Class and enumeration member names can be found by name lookup in any
+  // context in which a definition of the type is reachable.
+  //
+  // FIXME: The current implementation didn't consider about scope. For example,
+  // ```
+  // // m.cppm
+  // export module m;
+  // enum E1 { e1 };
+  // // Use.cpp
+  // import m;
+  // void test() {
+  //   auto a = E1::e1; // Error as expected.
+  //   auto b = e1; // Should be error. namespace-scope name e1 is not visible
+  // }
+  // ```
+  // For the above example, the current implementation would emit error for `a`
+  // correctly. However, the implementation wouldn't diagnose about `b` now.
+  // Since we only check the reachability for the parent only.
+  // See clang/test/CXX/module/module.interface/p7.cpp for example.
+  if (auto *TD = dyn_cast<TagDecl>(DC))
+    return SemaRef.hasReachableDefinition(TD);
+
+  return false;
+}
+
 /// Perform unqualified name lookup starting from a given
 /// scope.
 ///
 /// Unqualified name lookup (C++ [basic.lookup.unqual], C99 6.2.1) is
 /// used to find names within the current scope. For example, 'x' in
 /// @code
 /// int x;
 /// int f() {
for (auto *D : R) {
            D = cast_or_null<NamedDecl>(D->getPreviousDecl())) {
         if (D->getIdentifierNamespace() & Decl::IDNS_Ordinary) {
           if (isVisible(D)) {
             Visible = true;
             break;
           }
         } else if (D->getFriendObjectKind()) {
           auto *RD = cast<CXXRecordDecl>(D->getLexicalDeclContext());
-          if (AssociatedClasses.count(RD) && isVisible(D)) {
+          // [basic.lookup.argdep]p4:
+          //   Argument-dependent lookup finds all declarations of functions and
+          //   function templates that
+          //  - ...
+          //  - are declared as a friend ([class.friend]) of any class with a
+          //  reachable definition in the set of associated entities,
+          //
+          // FIXME: If there's a merged definition of D that is reachable, then
+          // the friend declaration should be considered.
+          if (AssociatedClasses.count(RD) && isReachable(D)) {
             Visible = true;
             break;
           }
         }
       }
 
       // FIXME: Preserve D as the FoundDecl.
       if (Visible)

clang/lib/Sema/SemaModule.cpp

Sema::ActOnGlobalModuleFragmentDecl(SourceLocation ModuleLoc) {
 
   // We start in the global module; all those declarations are implicitly
   // module-private (though they do not have module linkage).
   Module *GlobalModule =
       PushGlobalModuleFragment(ModuleLoc, /*IsImplicit=*/false);
 
   // All declarations created from now on are owned by the global module.
   auto *TU = Context.getTranslationUnitDecl();
-  TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::Visible);
+  // [module.global.frag]p2
+  // A global-module-fragment specifies the contents of the global module
+  // fragment for a module unit. The global module fragment can be used to
+  // provide declarations that are attached to the global module and usable
+  // within the module unit.
+  //
+  // So the declations in the global module shouldn't be visible by default.
+  TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ReachableWhenImported);
   TU->setLocalOwningModule(GlobalModule);
 
   // FIXME: Consider creating an explicit representation of this declaration.
   return nullptr;
 }
 
 void Sema::HandleStartOfHeaderUnit() {
   assert(getLangOpts().CPlusPlusModules &&
Sema::ActOnModuleDecl(SourceLocation StartLoc, SourceLocation ModuleLoc,
   // Switch from the global module fragment (if any) to the named module.
   ModuleScopes.back().BeginLoc = StartLoc;
   ModuleScopes.back().Module = Mod;
   ModuleScopes.back().ModuleInterface = MDK != ModuleDeclKind::Implementation;
   ModuleScopes.back().IsPartition = IsPartition;
   VisibleModules.setVisible(Mod, ModuleLoc);
 
   // From now on, we have an owning module for all declarations we see.
-  // However, those declarations are module-private unless explicitly
+  // In C++20 modules, those declaration would be reachable when imported
+  // unless explicitily exported.
+  // Otherwise, those declarations are module-private unless explicitly
   // exported.
   auto *TU = Context.getTranslationUnitDecl();
-  TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ModulePrivate);
+  TU->setModuleOwnershipKind(Decl::ModuleOwnershipKind::ReachableWhenImported);
   TU->setLocalOwningModule(Mod);
 
   // We are in the module purview, but before any other (non import)
   // statements, so imports are allowed.
   ImportState = ModuleImportState::ImportAllowed;
 
   // FIXME: Create a ModuleDecl.
   return nullptr;

clang/lib/Sema/SemaTemplate.cpp

assert(isa<TagDecl>(Instantiation) || isa<FunctionDecl>(Instantiation) ||
          isa<VarDecl>(Instantiation));
 
   bool IsEntityBeingDefined = false;
   if (const TagDecl *TD = dyn_cast_or_null<TagDecl>(PatternDef))
     IsEntityBeingDefined = TD->isBeingDefined();
 
   if (PatternDef && !IsEntityBeingDefined) {
     NamedDecl *SuggestedDef = nullptr;
-    if (!hasVisibleDefinition(const_cast<NamedDecl*>(PatternDef), &SuggestedDef,
-                              /*OnlyNeedComplete*/false)) {
+    if (!hasReachableDefinition(const_cast<NamedDecl *>(PatternDef),
+                                &SuggestedDef,
+                                /*OnlyNeedComplete*/ false)) {
       // If we're allowed to diagnose this and recover, do so.
       bool Recover = Complain && !isSFINAEContext();
       if (Complain)
         diagnoseMissingImport(PointOfInstantiation, SuggestedDef,
                               Sema::MissingImportKind::Definition, Recover);
       return !Recover;
     }
     return false;
Sema::SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
                                               SourceLocation RAngleLoc,
                                               Decl *Param,
                                               SmallVectorImpl<TemplateArgument>
                                                 &Converted,
                                               bool &HasDefaultArg) {
   HasDefaultArg = false;
 
   if (TemplateTypeParmDecl *TypeParm = dyn_cast<TemplateTypeParmDecl>(Param)) {
-    if (!hasVisibleDefaultArgument(TypeParm))
+    if (!hasReachableDefaultArgument(TypeParm))
       return TemplateArgumentLoc();
 
     HasDefaultArg = true;
     TypeSourceInfo *DI = SubstDefaultTemplateArgument(*this, Template,
                                                       TemplateLoc,
                                                       RAngleLoc,
                                                       TypeParm,
                                                       Converted);
     if (DI)
       return TemplateArgumentLoc(TemplateArgument(DI->getType()), DI);
 
     return TemplateArgumentLoc();
   }
 
   if (NonTypeTemplateParmDecl *NonTypeParm
         = dyn_cast<NonTypeTemplateParmDecl>(Param)) {
-    if (!hasVisibleDefaultArgument(NonTypeParm))
+    if (!hasReachableDefaultArgument(NonTypeParm))
       return TemplateArgumentLoc();
 
     HasDefaultArg = true;
     ExprResult Arg = SubstDefaultTemplateArgument(*this, Template,
                                                   TemplateLoc,
                                                   RAngleLoc,
                                                   NonTypeParm,
                                                   Converted);
     if (Arg.isInvalid())
       return TemplateArgumentLoc();
 
     Expr *ArgE = Arg.getAs<Expr>();
     return TemplateArgumentLoc(TemplateArgument(ArgE), ArgE);
   }
 
   TemplateTemplateParmDecl *TempTempParm
     = cast<TemplateTemplateParmDecl>(Param);
-  if (!hasVisibleDefaultArgument(TempTempParm))
+  if (!hasReachableDefaultArgument(TempTempParm))
     return TemplateArgumentLoc();
 
   HasDefaultArg = true;
   NestedNameSpecifierLoc QualifierLoc;
   TemplateName TName = SubstDefaultTemplateArgument(*this, Template,
                                                     TemplateLoc,
                                                     RAngleLoc,
                                                     TempTempParm,
static bool diagnoseMissingArgument(Sema &S, SourceLocation Loc,
                                     const TemplateParmDecl *D,
                                     TemplateArgumentListInfo &Args) {
   // Dig out the most recent declaration of the template parameter; there may be
   // declarations of the template that are more recent than TD.
   D = cast<TemplateParmDecl>(cast<TemplateDecl>(TD->getMostRecentDecl())
                                  ->getTemplateParameters()
                                  ->getParam(D->getIndex()));
 
-  // If there's a default argument that's not visible, diagnose that we're
+  // If there's a default argument that's not reachable, diagnose that we're
   // missing a module import.
   llvm::SmallVector<Module*, 8> Modules;
-  if (D->hasDefaultArgument() && !S.hasVisibleDefaultArgument(D, &Modules)) {
+  if (D->hasDefaultArgument() && !S.hasReachableDefaultArgument(D, &Modules)) {
     S.diagnoseMissingImport(Loc, cast<NamedDecl>(TD),
                             D->getDefaultArgumentLoc(), Modules,
                             Sema::MissingImportKind::DefaultArgument,
                             /*Recover*/true);
     return true;
   }
 
   // FIXME: If there's a more recent default argument that *is* visible,
for (TemplateParameterList::iterator Param = Params->begin(),
     TemplateArgumentLoc Arg;
 
     // Retrieve the default template argument from the template
     // parameter. For each kind of template parameter, we substitute the
     // template arguments provided thus far and any "outer" template arguments
     // (when the template parameter was part of a nested template) into
     // the default argument.
     if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(*Param)) {
-      if (!hasVisibleDefaultArgument(TTP))
+      if (!hasReachableDefaultArgument(TTP))
         return diagnoseMissingArgument(*this, TemplateLoc, Template, TTP,
                                        NewArgs);
 
       TypeSourceInfo *ArgType = SubstDefaultTemplateArgument(*this,
                                                              Template,
                                                              TemplateLoc,
                                                              RAngleLoc,
                                                              TTP,
                                                              Converted);
       if (!ArgType)
         return true;
 
       Arg = TemplateArgumentLoc(TemplateArgument(ArgType->getType()),
                                 ArgType);
     } else if (NonTypeTemplateParmDecl *NTTP
                  = dyn_cast<NonTypeTemplateParmDecl>(*Param)) {
-      if (!hasVisibleDefaultArgument(NTTP))
+      if (!hasReachableDefaultArgument(NTTP))
         return diagnoseMissingArgument(*this, TemplateLoc, Template, NTTP,
                                        NewArgs);
 
       ExprResult E = SubstDefaultTemplateArgument(*this, Template,
                                                               TemplateLoc,
                                                               RAngleLoc,
                                                               NTTP,
                                                               Converted);
       if (E.isInvalid())
         return true;
 
       Expr *Ex = E.getAs<Expr>();
       Arg = TemplateArgumentLoc(TemplateArgument(Ex), Ex);
     } else {
       TemplateTemplateParmDecl *TempParm
         = cast<TemplateTemplateParmDecl>(*Param);
 
-      if (!hasVisibleDefaultArgument(TempParm))
+      if (!hasReachableDefaultArgument(TempParm))
         return diagnoseMissingArgument(*this, TemplateLoc, Template, TempParm,
                                        NewArgs);
 
       NestedNameSpecifierLoc QualifierLoc;
       TemplateName Name = SubstDefaultTemplateArgument(*this, Template,
                                                        TemplateLoc,
                                                        RAngleLoc,
                                                        TempParm,

 ///   class template specialization that would make use of the partial
 ///   specialization as the result of an implicit or explicit instantiation
 ///   in every translation unit in which such a use occurs; no diagnostic is
 ///   required.
 class ExplicitSpecializationVisibilityChecker {
   Sema &S;
   SourceLocation Loc;
   llvm::SmallVector<Module *, 8> Modules;
+  Sema::AcceptableKind Kind;
 
 public:
-  ExplicitSpecializationVisibilityChecker(Sema &S, SourceLocation Loc)
-      : S(S), Loc(Loc) {}
+  ExplicitSpecializationVisibilityChecker(Sema &S, SourceLocation Loc,
+                                          Sema::AcceptableKind Kind)
+      : S(S), Loc(Loc), Kind(Kind) {}
 
   void check(NamedDecl *ND) {
     if (auto *FD = dyn_cast<FunctionDecl>(ND))
       return checkImpl(FD);
     if (auto *RD = dyn_cast<CXXRecordDecl>(ND))
       return checkImpl(RD);
     if (auto *VD = dyn_cast<VarDecl>(ND))
       return checkImpl(VD);
void diagnose(NamedDecl *D, bool IsPartialSpec) {
     // declarations are interesting), use them, otherwise let
     // diagnoseMissingImport intelligently pick some.
     if (Modules.empty())
       S.diagnoseMissingImport(Loc, D, Kind, Recover);
     else
       S.diagnoseMissingImport(Loc, D, D->getLocation(), Modules, Kind, Recover);
   }
 
+  bool CheckMemberSpecialization(const NamedDecl *D) {
+    return Kind == Sema::AcceptableKind::Visible
+               ? S.hasVisibleMemberSpecialization(D)
+               : S.hasReachableMemberSpecialization(D);
+  }
+
+  bool CheckExplicitSpecialization(const NamedDecl *D) {
+    return Kind == Sema::AcceptableKind::Visible
+               ? S.hasVisibleExplicitSpecialization(D)
+               : S.hasReachableExplicitSpecialization(D);
+  }
+
+  bool CheckDeclaration(const NamedDecl *D) {
+    return Kind == Sema::AcceptableKind::Visible ? S.hasVisibleDeclaration(D)
+                                                 : S.hasReachableDeclaration(D);
+  }
+
   // Check a specific declaration. There are three problematic cases:
   //
   //  1) The declaration is an explicit specialization of a template
   //     specialization.
   //  2) The declaration is an explicit specialization of a member of an
   //     templated class.
   //  3) The declaration is an instantiation of a template, and that template
   //     is an explicit specialization of a member of a templated class.
   //
   // We don't need to go any deeper than that, as the instantiation of the
   // surrounding class / etc is not triggered by whatever triggered this
   // instantiation, and thus should be checked elsewhere.
   template<typename SpecDecl>
   void checkImpl(SpecDecl *Spec) {
     bool IsHiddenExplicitSpecialization = false;
     if (Spec->getTemplateSpecializationKind() == TSK_ExplicitSpecialization) {
-      IsHiddenExplicitSpecialization =
-          Spec->getMemberSpecializationInfo()
-              ? !S.hasVisibleMemberSpecialization(Spec, &Modules)
-              : !S.hasVisibleExplicitSpecialization(Spec, &Modules);
+      IsHiddenExplicitSpecialization = Spec->getMemberSpecializationInfo()
+                                           ? !CheckMemberSpecialization(Spec)
+                                           : !CheckExplicitSpecialization(Spec);
     } else {
       checkInstantiated(Spec);
     }
 
     if (IsHiddenExplicitSpecialization)
       diagnose(Spec->getMostRecentDecl(), false);
   }
 
   void checkInstantiated(FunctionDecl *FD) {
     if (auto *TD = FD->getPrimaryTemplate())
       checkTemplate(TD);
   }
 
   void checkInstantiated(CXXRecordDecl *RD) {
     auto *SD = dyn_cast<ClassTemplateSpecializationDecl>(RD);
     if (!SD)
       return;
 
     auto From = SD->getSpecializedTemplateOrPartial();
     if (auto *TD = From.dyn_cast<ClassTemplateDecl *>())
       checkTemplate(TD);
     else if (auto *TD =
                  From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
-      if (!S.hasVisibleDeclaration(TD))
+      if (!CheckDeclaration(TD))
         diagnose(TD, true);
       checkTemplate(TD);
     }
   }
 
   void checkInstantiated(VarDecl *RD) {
     auto *SD = dyn_cast<VarTemplateSpecializationDecl>(RD);
     if (!SD)
       return;
 
     auto From = SD->getSpecializedTemplateOrPartial();
     if (auto *TD = From.dyn_cast<VarTemplateDecl *>())
       checkTemplate(TD);
     else if (auto *TD =
                  From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
-      if (!S.hasVisibleDeclaration(TD))
+      if (!CheckDeclaration(TD))
         diagnose(TD, true);
       checkTemplate(TD);
     }
   }
 
   void checkInstantiated(EnumDecl *FD) {}
 
   template<typename TemplDecl>
   void checkTemplate(TemplDecl *TD) {
     if (TD->isMemberSpecialization()) {
-      if (!S.hasVisibleMemberSpecialization(TD, &Modules))
+      if (!CheckMemberSpecialization(TD))
         diagnose(TD->getMostRecentDecl(), false);
     }
   }
 };
 } // end anonymous namespace
 
 void Sema::checkSpecializationVisibility(SourceLocation Loc, NamedDecl *Spec) {
   if (!getLangOpts().Modules)
     return;
 
-  ExplicitSpecializationVisibilityChecker(*this, Loc).check(Spec);
+  ExplicitSpecializationVisibilityChecker(*this, Loc,
+                                          Sema::AcceptableKind::Visible)
+      .check(Spec);
+}
+
+void Sema::checkSpecializationReachability(SourceLocation Loc,
+                                           NamedDecl *Spec) {
+  if (!getLangOpts().CPlusPlusModules)
+    return checkSpecializationVisibility(Loc, Spec);
+
+  ExplicitSpecializationVisibilityChecker(*this, Loc,
+                                          Sema::AcceptableKind::Reachable)
+      .check(Spec);
 }

clang/lib/Sema/SemaType.cpp

bool Sema::hasStructuralCompatLayout(Decl *D, Decl *Suggested) {
   StructuralEquivalenceContext Ctx(
       D->getASTContext(), Suggested->getASTContext(), NonEquivalentDecls,
       StructuralEquivalenceKind::Default,
       false /*StrictTypeSpelling*/, true /*Complain*/,
       true /*ErrorOnTagTypeMismatch*/);
   return Ctx.IsEquivalent(D, Suggested);
 }
 
-/// Determine whether there is any declaration of \p D that was ever a
-///        definition (perhaps before module merging) and is currently visible.
-/// \param D The definition of the entity.
-/// \param Suggested Filled in with the declaration that should be made visible
-///        in order to provide a definition of this entity.
-/// \param OnlyNeedComplete If \c true, we only need the type to be complete,
-///        not defined. This only matters for enums with a fixed underlying
-///        type, since in all other cases, a type is complete if and only if it
-///        is defined.
-bool Sema::hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested,
-                                bool OnlyNeedComplete) {
+bool Sema::hasAcceptableDefinition(NamedDecl *D, NamedDecl **Suggested,
+                                   AcceptableKind Kind, bool OnlyNeedComplete) {
   // Easy case: if we don't have modules, all declarations are visible.
   if (!getLangOpts().Modules && !getLangOpts().ModulesLocalVisibility)
     return true;
 
   // If this definition was instantiated from a template, map back to the
   // pattern from which it was instantiated.
   if (isa<TagDecl>(D) && cast<TagDecl>(D)->isBeingDefined()) {
     // We're in the middle of defining it; this definition should be treated
if (isa<TagDecl>(D) && cast<TagDecl>(D)->isBeingDefined()) {
     if (auto *Pattern = FD->getTemplateInstantiationPattern())
       FD = Pattern;
     D = FD->getDefinition();
   } else if (auto *VD = dyn_cast<VarDecl>(D)) {
     if (auto *Pattern = VD->getTemplateInstantiationPattern())
       VD = Pattern;
     D = VD->getDefinition();
   }
+
   assert(D && "missing definition for pattern of instantiated definition");
 
   *Suggested = D;
 
-  auto DefinitionIsVisible = [&] {
+  auto DefinitionIsAcceptable = [&] {
     // The (primary) definition might be in a visible module.
-    if (isVisible(D))
+    if (isAcceptable(D, Kind))
       return true;
 
     // A visible module might have a merged definition instead.
     if (D->isModulePrivate() ? hasMergedDefinitionInCurrentModule(D)
                              : hasVisibleMergedDefinition(D)) {
       if (CodeSynthesisContexts.empty() &&
           !getLangOpts().ModulesLocalVisibility) {
         // Cache the fact that this definition is implicitly visible because
         // there is a visible merged definition.
         D->setVisibleDespiteOwningModule();
       }
       return true;
     }
 
     return false;
   };
 
-  if (DefinitionIsVisible())
+  if (DefinitionIsAcceptable())
     return true;
 
   // The external source may have additional definitions of this entity that are
   // visible, so complete the redeclaration chain now and ask again.
   if (auto *Source = Context.getExternalSource()) {
     Source->CompleteRedeclChain(D);
-    return DefinitionIsVisible();
+    return DefinitionIsAcceptable();
   }
 
   return false;
 }
 
+/// Determine whether there is any declaration of \p D that was ever a
+///        definition (perhaps before module merging) and is currently visible.
+/// \param D The definition of the entity.
+/// \param Suggested Filled in with the declaration that should be made visible
+///        in order to provide a definition of this entity.
+/// \param OnlyNeedComplete If \c true, we only need the type to be complete,
+///        not defined. This only matters for enums with a fixed underlying
+///        type, since in all other cases, a type is complete if and only if it
+///        is defined.
+bool Sema::hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested,
+                                bool OnlyNeedComplete) {
+  return hasAcceptableDefinition(D, Suggested, Sema::AcceptableKind::Visible,
+                                 OnlyNeedComplete);
+}
+
+/// Determine whether there is any declaration of \p D that was ever a
+///        definition (perhaps before module merging) and is currently
+///        reachable.
+/// \param D The definition of the entity.
+/// \param Suggested Filled in with the declaration that should be made
+/// reachable
+///        in order to provide a definition of this entity.
+/// \param OnlyNeedComplete If \c true, we only need the type to be complete,
+///        not defined. This only matters for enums with a fixed underlying
+///        type, since in all other cases, a type is complete if and only if it
+///        is defined.
+bool Sema::hasReachableDefinition(NamedDecl *D, NamedDecl **Suggested,
+                                  bool OnlyNeedComplete) {
+  return hasAcceptableDefinition(D, Suggested, Sema::AcceptableKind::Reachable,
+                                 OnlyNeedComplete);
+}
+
 /// Locks in the inheritance model for the given class and all of its bases.
 static void assignInheritanceModel(Sema &S, CXXRecordDecl *RD) {
   RD = RD->getMostRecentNonInjectedDecl();
   if (!RD->hasAttr<MSInheritanceAttr>()) {
     MSInheritanceModel IM;
     bool BestCase = false;
     switch (S.MSPointerToMemberRepresentationMethod) {
     case LangOptions::PPTMK_BestCase:
       BestCase = true;
       IM = RD->calculateInheritanceModel();
       break;
     case LangOptions::PPTMK_FullGeneralitySingleInheritance:
       IM = MSInheritanceModel::Single;
if (!RD->hasAttr<MSInheritanceAttr>()) {
     RD->addAttr(MSInheritanceAttr::CreateImplicit(
         S.getASTContext(), BestCase, Loc, AttributeCommonInfo::AS_Microsoft,
         MSInheritanceAttr::Spelling(IM)));
     S.Consumer.AssignInheritanceModel(RD);
   }
 }
 
 /// The implementation of RequireCompleteType
 bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
                                    CompleteTypeKind Kind,
                                    TypeDiagnoser *Diagnoser) {
   // FIXME: Add this assertion to make sure we always get instantiation points.
   //  assert(!Loc.isInvalid() && "Invalid location in RequireCompleteType");
   // FIXME: Add this assertion to help us flush out problems with
   // checking for dependent types and type-dependent expressions.
   //
   //  assert(!T->isDependentType() &&
   //         "Can't ask whether a dependent type is complete");
 
   if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>()) {
bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T,
   NamedDecl *Def = nullptr;
   bool AcceptSizeless = (Kind == CompleteTypeKind::AcceptSizeless);
   bool Incomplete = (T->isIncompleteType(&Def) ||
                      (!AcceptSizeless && T->isSizelessBuiltinType()));
 
   // Check that any necessary explicit specializations are visible. For an
   // enum, we just need the declaration, so don't check this.
   if (Def && !isa<EnumDecl>(Def))
-    checkSpecializationVisibility(Loc, Def);
+    checkSpecializationReachability(Loc, Def);
 
   // If we have a complete type, we're done.
   if (!Incomplete) {
-    // If we know about the definition but it is not visible, complain.
-    NamedDecl *SuggestedDef = nullptr;
+    NamedDecl *Suggested = nullptr;
     if (Def &&
-        !hasVisibleDefinition(Def, &SuggestedDef, /*OnlyNeedComplete*/true)) {
+        !hasReachableDefinition(Def, &Suggested, /*OnlyNeedComplete=*/true)) {
       // If the user is going to see an error here, recover by making the
       // definition visible.
       bool TreatAsComplete = Diagnoser && !isSFINAEContext();
-      if (Diagnoser && SuggestedDef)
-        diagnoseMissingImport(Loc, SuggestedDef, MissingImportKind::Definition,
-                              /*Recover*/TreatAsComplete);
+      if (Diagnoser && Suggested)
+        diagnoseMissingImport(Loc, Suggested, MissingImportKind::Definition,
+                              /*Recover*/ TreatAsComplete);
       return !TreatAsComplete;
     } else if (Def && !TemplateInstCallbacks.empty()) {
       CodeSynthesisContext TempInst;
       TempInst.Kind = CodeSynthesisContext::Memoization;
       TempInst.Template = Def;
       TempInst.Entity = Def;
       TempInst.PointOfInstantiation = Loc;
       atTemplateBegin(TemplateInstCallbacks, *this, TempInst);

clang/lib/Serialization/ASTReaderDecl.cpp

void ASTDeclReader::VisitDecl(Decl *D) {
   }
   D->setImplicit(Record.readInt());
   D->Used = Record.readInt();
   IsDeclMarkedUsed |= D->Used;
   D->setReferenced(Record.readInt());
   D->setTopLevelDeclInObjCContainer(Record.readInt());
   D->setAccess((AccessSpecifier)Record.readInt());
   D->FromASTFile = true;
-  bool ModulePrivate = Record.readInt();
+  auto ModuleOwnership = (Decl::ModuleOwnershipKind)Record.readInt();
+  bool ModulePrivate =
+      (ModuleOwnership == Decl::ModuleOwnershipKind::ModulePrivate);
 
   // Determine whether this declaration is part of a (sub)module. If so, it
   // may not yet be visible.
   if (unsigned SubmoduleID = readSubmoduleID()) {
+
+    switch (ModuleOwnership) {
+    case Decl::ModuleOwnershipKind::Visible:
+      ModuleOwnership = Decl::ModuleOwnershipKind::VisibleWhenImported;
+      break;
+    case Decl::ModuleOwnershipKind::Unowned:
+    case Decl::ModuleOwnershipKind::VisibleWhenImported:
+    case Decl::ModuleOwnershipKind::ReachableWhenImported:
+    case Decl::ModuleOwnershipKind::ModulePrivate:
+      break;
+    }
+
+    D->setModuleOwnershipKind(ModuleOwnership);
     // Store the owning submodule ID in the declaration.
-    D->setModuleOwnershipKind(
-        ModulePrivate ? Decl::ModuleOwnershipKind::ModulePrivate
-                      : Decl::ModuleOwnershipKind::VisibleWhenImported);
     D->setOwningModuleID(SubmoduleID);
 
     if (ModulePrivate) {
       // Module-private declarations are never visible, so there is no work to
       // do.
     } else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
       // If local visibility is being tracked, this declaration will become
       // hidden and visible as the owning module does.

clang/lib/Serialization/ASTWriterDecl.cpp

void ASTDeclWriter::VisitDecl(Decl *D) {
   Record.push_back(D->hasAttrs());
   if (D->hasAttrs())
     Record.AddAttributes(D->getAttrs());
   Record.push_back(D->isImplicit());
   Record.push_back(D->isUsed(false));
   Record.push_back(D->isReferenced());
   Record.push_back(D->isTopLevelDeclInObjCContainer());
   Record.push_back(D->getAccess());
-  Record.push_back(D->isModulePrivate());
+  Record.push_back((uint64_t)D->getModuleOwnershipKind());
   Record.push_back(Writer.getSubmoduleID(D->getOwningModule()));
 
   // If this declaration injected a name into a context different from its
   // lexical context, and that context is an imported namespace, we need to
   // update its visible declarations to include this name.
   //
   // This happens when we instantiate a class with a friend declaration or a
   // function with a local extern declaration, for instance.
void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));  // AccessSpecifier
-  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));  // ModuleOwnershipKind
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
   // NamedDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
   // ValueDecl
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
   // DeclaratorDecl
void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2));  // AccessSpecifier
-  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3));  // ModuleOwnershipKind
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
   // NamedDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
   // ValueDecl
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
   // DeclaratorDecl
void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
-  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
   // NamedDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
   // TypeDecl
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
-  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
   // NamedDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
   // TypeDecl
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
-  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
   // NamedDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
   // ValueDecl
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
   // DeclaratorDecl
void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isUsed
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // isReferenced
   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // C++ AccessSpecifier
-  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
   // NamedDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
   // TypeDecl
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Source Location
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type Ref
void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(0));                       // LexicalDeclContext
   Abv->Add(BitCodeAbbrevOp(0));                       // isInvalidDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // HasAttrs
   Abv->Add(BitCodeAbbrevOp(0));                       // isImplicit
   Abv->Add(BitCodeAbbrevOp(0));                       // isUsed
   Abv->Add(BitCodeAbbrevOp(0));                       // isReferenced
   Abv->Add(BitCodeAbbrevOp(0));                   // TopLevelDeclInObjCContainer
   Abv->Add(BitCodeAbbrevOp(AS_none));                 // C++ AccessSpecifier
-  Abv->Add(BitCodeAbbrevOp(0));                       // ModulePrivate
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // SubmoduleID
   // NamedDecl
   Abv->Add(BitCodeAbbrevOp(0));                       // NameKind = Identifier
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Name
   Abv->Add(BitCodeAbbrevOp(0));                       // AnonDeclNumber
   // ValueDecl
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6)); // Type
   // DeclaratorDecl
void ASTWriter::WriteDeclAbbrevs() {
   Abv->Add(BitCodeAbbrevOp(0));                         // LexicalDeclContext
   Abv->Add(BitCodeAbbrevOp(0));                         // Invalid
   Abv->Add(BitCodeAbbrevOp(0));                         // HasAttrs
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Implicit
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Used
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // Referenced
   Abv->Add(BitCodeAbbrevOp(0));                         // InObjCContainer
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 2)); // Access
-  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 1)); // ModulePrivate
+  Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 3)); // ModuleOwnershipKind
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // SubmoduleID
   // NamedDecl
   Abv->Add(BitCodeAbbrevOp(DeclarationName::Identifier)); // NameKind
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Identifier
   Abv->Add(BitCodeAbbrevOp(0));                         // AnonDeclNumber
   // ValueDecl
   Abv->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::VBR, 6));   // Type
   // DeclaratorDecl

clang/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4-friend-in-reachable-class.cpp

+// This tests for [basic.lookup.argdep]/p4.2:
+//   Argument-dependent lookup finds all declarations of functions and function templates that
+// - ...
+// - are declared as a friend ([class.friend]) of any class with a reachable definition in the set of associated entities,
+//
+// RUN: rm -fr %t
+// RUN: mkdir %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/Friend-in-reachable-class.cppm -o %t/X.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -verify -fsyntax-only
+//
+//--- Friend-in-reachable-class.cppm
+module;
+# 3 __FILE__ 1
+struct A {
+  friend int operator+(const A &lhs, const A &rhs) {
+    return 0;
+  }
+};
+# 6 "" 2
+export module X;
+export using ::A;
+
+//--- Use.cpp
+// expected-no-diagnostics
+import X;
+int use() {
+  A a, b;
+  return a + b;
+}

clang/test/CXX/basic/basic.scope/basic.scope.namespace/p2.cpp

 #else
 
 #ifdef IMPLEMENTATION
 module;
 #endif
 
 void test_early() {
   in_header = 1; // expected-error {{missing '#include "foo.h"'; 'in_header' must be declared before it is used}}
-  // expected-note@*{{not visible}}
+  // expected-note@* {{not visible}}
 
   global_module_fragment = 1; // expected-error {{missing '#include'; 'global_module_fragment' must be declared before it is used}}
                               // [e-mail]:16 {{not visible}}
 
   exported = 1; // expected-error {{must be imported from module 'A'}}
-  // [e-mail]:18 {{not visible}}
+                // [e-mail]:18 {{declaration here is not visible}}
 
-  not_exported = 1; // expected-error {{undeclared identifier}}
+  not_exported = 1; // expected-error {{declaration of 'not_exported' must be imported from module 'A' before it is required}}
+                    // [e-mail]:19 {{declaration here is not visible}}
 
-  internal = 1; // expected-error {{undeclared identifier}}
+  // FIXME: We need better diagnostic message for static variable.
+  internal = 1; // expected-error {{declaration of 'internal' must be imported from module 'A' before it is required}}
+                // [e-mail]:20 {{declaration here is not visible}}
 
   not_exported_private = 1; // expected-error {{undeclared identifier}}
 
   internal_private = 1; // expected-error {{undeclared identifier}}
 }
 
 #ifdef IMPLEMENTATION
 module A;
 #else
 import A;
 #endif
 
 void test_late() {
   in_header = 1; // expected-error {{missing '#include "foo.h"'; 'in_header' must be declared before it is used}}
-  // expected-note@*{{not visible}}
+  // expected-note@* {{not visible}}
 
   global_module_fragment = 1; // expected-error {{missing '#include'; 'global_module_fragment' must be declared before it is used}}
   // [e-mail]:16 {{not visible}}
 
   exported = 1;
 
   not_exported = 1;
 #ifndef IMPLEMENTATION
-  // expected-error@-2 {{undeclared identifier 'not_exported'; did you mean 'exported'}}
-  // [e-mail]:18 {{declared here}}
+  // expected-error@-2 {{declaration of 'not_exported' must be imported from module 'A' before it is required}}
+  // [e-mail]:19 {{declaration here is not visible}}
 #endif
 
   internal = 1;
 #ifndef IMPLEMENTATION
-  // FIXME: should not be visible here
-  // expected-error@-3 {{undeclared identifier}}
+  // expected-error@-2 {{declaration of 'internal' must be imported from module 'A' before it is required}}
+  // [e-mail]:20 {{declaration here is not visible}}
 #endif
 
   not_exported_private = 1;
 #ifndef IMPLEMENTATION
   // FIXME: should not be visible here
   // expected-error@-3 {{undeclared identifier}}
 #endif
 
   internal_private = 1;
 #ifndef IMPLEMENTATION
   // FIXME: should not be visible here
   // expected-error@-3 {{undeclared identifier}}
 #endif
 }
 
 #endif

clang/test/CXX/module/module.context/p7.cpp

+// RUN: rm -rf %t
+// RUN: split-file %s %t
+// RUN: cd %t
+
+// RUN: %clang_cc1 -std=c++20 -emit-header-unit -xc++-header-unit-header std-10-6-ex1-decl.h \
+// RUN: -o decl.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-header-unit -xc++-header-unit-header std-10-6-ex1-defn.h \
+// RUN: -o defn.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-6-ex1-stuff.cpp \
+// RUN: -o stuff.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-6-ex1-M1.cpp \
+// RUN: -fmodule-file=stuff.pcm -o M1.pcm  -fmodule-file=defn.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface std-10-6-ex1-M2.cpp \
+// RUN: -fmodule-file=stuff.pcm -o M2.pcm  -fmodule-file=decl.pcm
+
+// RUN: %clang_cc1 -std=c++20 std-10-6-ex1-use.cpp \
+// RUN: -fmodule-file=M1.pcm -fmodule-file=M2.pcm  -fsyntax-only -verify
+
+//--- std-10-6-ex1-decl.h
+struct X;
+
+//--- std-10-6-ex1-defn.h
+struct X {};
+
+//--- std-10-6-ex1-stuff.cpp
+export module stuff;
+export template <typename T, typename U> void foo(T, U u) { auto v = u; }
+export template <typename T, typename U> void bar(T, U u) { auto v = *u; }
+
+//--- std-10-6-ex1-M1.cpp
+export module M1;
+import "std-10-6-ex1-defn.h"; // provides struct X {};
+import stuff;
+
+export template <typename T> void f(T t) {
+  X x;
+  foo(t, x);
+}
+
+//--- std-10-6-ex1-M2.cpp
+export module M2;
+import "std-10-6-ex1-decl.h"; // provides struct X; (not a definition)
+
+import stuff;
+export template <typename T> void g(T t) {
+  X *x;
+  bar(t, x);
+}
+
+//--- std-10-6-ex1-use.cpp
+import M1;
+import M2;
+
+void test() {
+  f(0);
+  // It is unspecified whether the instantiation of g(0) is valid here.
+  // We choose to make it invalid here.
+  g(0); // expected-error@* {{definition of 'X' must be imported from module}}
+        // expected-note@* {{in instantiation of function template specialization 'bar<int, X *>'}}
+        // expected-note@* {{in instantiation of function template specialization}}
+        // expected-note@* {{definition here is not reachable}}
+}

clang/test/CXX/module/module.import/p2.cpp

 //--- M.cppm
 export module M;
 import :impl;
 export A f();
 
 //--- Use.cpp
 import M;
 void test() {
-  A a; // expected-error {{unknown type name 'A'}}
+  A a; // expected-error {{declaration of 'A' must be imported from module 'M:impl'}}
+       // expected-error@-1 {{definition of 'A' must be imported from module 'M:impl'}} expected-error@-1 {{}}
+       // [e-mail]:2 {{declaration here is not visible}}
+       // [e-mail]:2 {{definition here is not reachable}} [e-mail]:2 {{}}
 }
 
 //--- UseInPartA.cppm
 // expected-no-diagnostics
 export module M:partA;
 import :impl;
 void test() {
   A a;
 }
 
 //--- UseInAnotherModule.cppm
 export module B;
 import M;
 void test() {
-  A a; // expected-error {{unknown type name 'A'}}
+  A a; // expected-error {{declaration of 'A' must be imported from module 'M:impl'}}
+       // expected-error@-1 {{definition of 'A' must be imported from module 'M:impl'}} expected-error@-1 {{}}
+       // [e-mail]:2 {{declaration here is not visible}}
+       // [e-mail]:2 {{definition here is not reachable}} [e-mail]:2 {{}}
 }
 
 //--- Private.cppm
 export module A;
 module :private;
 
 class A {};
 void test() {

clang/test/CXX/module/module.interface/p2.cpp

 int use_header() { return foo + bar::baz(); }
 
 #elif defined(USER)
 import p2;
 import "header.h";
 
 void use() {
   // namespace A is implicitly exported by the export of A::g.
-  A::f(); // expected-error {{no member named 'f' in namespace 'A'}}
+  A::f(); // expected-error {{declaration of 'f' must be imported from module 'p2' before it is required}}
+          // expected-note@* {{declaration here is not visible}}
   A::g();
-  A::h(); // expected-error {{no member named 'h' in namespace 'A'}}
-  using namespace A::inner; // expected-error {{expected namespace name}}
+  A::h();                   // expected-error {{declaration of 'h' must be imported from module 'p2' before it is required}}
+                            // expected-note@* {{declaration here is not visible}}
+  using namespace A::inner; // expected-error {{declaration of 'inner' must be imported from module 'p2' before it is required}}
+                            // expected-note@* {{declaration here is not visible}}
 
   // namespace B and B::inner are explicitly exported
   using namespace B;
   using namespace B::inner;
-  B::f(); // expected-error {{no member named 'f' in namespace 'B'}}
-  f(); // expected-error {{undeclared identifier 'f'}}
+  B::f(); // expected-error {{declaration of 'f' must be imported from module 'p2' before it is required}}
+          // expected-note@* {{declaration here is not visible}}
+  f();    // expected-error {{declaration of 'f' must be imported from module 'p2' before it is required}}
+          // expected-note@* {{declaration here is not visible}}
 
   // namespace C is not exported
-  using namespace C; // expected-error {{expected namespace name}}
+  using namespace C; // expected-error {{declaration of 'C' must be imported from module 'p2' before it is required}}
+                     // expected-note@* {{declaration here is not visible}}
 
   // namespace D is exported, but D::f is not
-  D::f(); // expected-error {{no member named 'f' in namespace 'D'}}
+  D::f(); // expected-error {{declaration of 'f' must be imported from module 'p2' before it is required}}
+          // expected-note@* {{declaration here is not visible}}
 }
 
 int use_header() { return foo + bar::baz(); }
 
 #else
 #error unknown mode
 #endif

clang/test/CXX/module/module.interface/p7.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/p7.cppm -emit-module-interface -o %t/p7.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -verify
+
+//--- p7.cppm
+export module p7;
+struct reachable {
+  constexpr static int sv = 43;
+  int value = 44;
+
+  static int getValue() { return 43; }
+  int get() { return 44; }
+
+  template <typename T>
+  static bool templ_get(T t) { return false; }
+  typedef int typedef_type;
+  using using_type = int;
+  template <typename T>
+  using templ_using_type = int;
+  bool operator()() {
+    return false;
+  }
+
+  enum E { a,
+           b };
+};
+
+export auto getReachable() {
+  return reachable{};
+}
+
+export enum E1 { e1 };
+enum E2 { e2 };
+export using E2U = E2;
+enum E3 { e3 };
+export E3 func();
+
+//--- Use.cpp
+import p7;
+void test() {
+  auto reachable = getReachable();
+  int a = decltype(reachable)::sv;
+  int b = decltype(reachable)::getValue();
+  int c = reachable.value;
+  int d = reachable.get();
+  int e = decltype(reachable)::a;
+  int f = reachable.templ_get(a);
+  typename decltype(reachable)::typedef_type g;
+  typename decltype(reachable)::using_type h;
+  typename decltype(reachable)::template templ_using_type<int> j;
+  auto value = reachable();
+}
+
+void test2() {
+  auto a = E1::e1;               // OK, namespace-scope name E1 is visible and e1 is reachable
+  auto b = e1;                   // OK, namespace-scope name e1 is visible
+  auto c = E2::e2;               // expected-error {{declaration of 'E2' must be imported from module}}
+                                 // expected-note@* {{declaration here is not visible}}
+  auto d = e2;                   // should be error, namespace-scope name e2 is not visible
+  auto e = E2U::e2;              // OK, namespace-scope name E2U is visible and E2::e2 is reachable
+  auto f = E3::e3;               // expected-error {{declaration of 'E3' must be imported from module 'p7' before it is required}}
+                                 // expected-note@* {{declaration here is not visible}}
+  auto g = e3;                   // should be error, namespace-scope name e3 is not visible
+  auto h = decltype(func())::e3; // OK, namespace-scope name f is visible and E3::e3 is reachable
+}

clang/test/CXX/module/module.reach/ex1.cpp

+// From [module.reach]p4, example 1
+//
+// RUN: rm -fr %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/M-A.cppm -o %t/M-A.pcm
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface -fprebuilt-module-path=%t %t/M-B-impl.cppm -o %t/M-B.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/M-C.cppm -fsyntax-only -verify
+//
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface -fprebuilt-module-path=%t %t/M.cppm -o %t/M.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/X.cppm -fsyntax-only -verify
+//
+//--- M-A.cppm
+export module M:A;
+export struct B;
+
+//--- M-B-impl.cppm
+module M:B;
+struct B {
+  operator int();
+};
+
+//--- M-C.cppm
+module M:C;
+import :A;
+B b1; // expected-error {{variable has incomplete type 'B'}}
+      // expected-note@* {{forward declaration of 'B'}}
+
+//--- M.cppm
+export module M;
+export import :A;
+import :B;
+B b2;
+export void f(B b = B());
+
+//--- X.cppm
+export module X;
+import M;
+B b3; // expected-error {{definition of 'B' must be imported from module 'M:B' before it is required}} expected-error {{}}
+      // expected-note@* {{definition here is not reachable}} expected-note@* {{}}
+// FIXME: We should emit an error for unreachable definition of B.
+void g() { f(); }

clang/test/CXX/module/module.reach/p2.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+// RUN: %clang_cc1 -std=c++20 %t/impl.cppm -emit-module-interface -o %t/M-impl.pcm
+// RUN: %clang_cc1 -std=c++20 %t/M.cppm -emit-module-interface -fprebuilt-module-path=%t -o %t/M.pcm
+// RUN: %clang_cc1 -std=c++20 %t/UseStrict.cpp -fprebuilt-module-path=%t -verify -fsyntax-only
+
+//--- impl.cppm
+module M:impl;
+class A {};
+
+//--- M.cppm
+export module M;
+import :impl;
+export A f();
+
+//--- UseStrict.cpp
+import M;
+void test() {
+  auto a = f(); // expected-error {{definition of 'A' must be imported from module 'M:impl' before it is required}} expected-error{{}}
+                // expected-note@* {{definition here is not reachable}} expected-note@* {{}}
+}

clang/test/CXX/module/module.reach/p4/TransitiveImport.cpp

+// RUN: rm -fr %t
+// RUN: mkdir %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/foo.cppm -emit-module-interface -o %t/foo.pcm
+// RUN: %clang_cc1 -std=c++20 %t/bar.cppm -emit-module-interface -fprebuilt-module-path=%t -o %t/bar.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t -verify %t/Use.cpp -fsyntax-only
+//
+//--- foo.cppm
+export module foo;
+export class foo {
+};
+
+//--- bar.cppm
+export module bar;
+import foo;
+export auto bar() {
+  return foo{};
+}
+
+//--- Use.cpp
+// expected-no-diagnostics
+import bar;
+auto foo() {
+  // [module.reach]Note1:
+  // While module interface units are reachable even when they
+  // are only transitively imported via a non-exported import declaration,
+  // namespace-scope names from such module interface units are not found
+  // by name lookup ([basic.lookup]).
+  auto b = bar(); // foo should be reachable here.
+}

clang/test/CXX/module/module.reach/p5.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/A.cppm -emit-module-interface -o %t/A.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/B.cppm -fsyntax-only -verify
+//
+//--- A.cppm
+export module A;
+struct X {};
+export using Y = X;
+
+//--- B.cppm
+export module B;
+import A;
+Y y; // OK, definition of X is reachable
+X x; // expected-error {{declaration of 'X' must be imported from module 'A' before it is required}}
+     // expected-note@* {{declaration here is not visible}}

clang/test/CXX/module/module.unit/p7/t6.cpp

 // RUN: rm -fr %t
 // RUN: mkdir %t
 // RUN: %clang_cc1 -std=c++20 -emit-module-interface %S/Inputs/CPP.cppm -I%S/Inputs -o %t/X.pcm
 // RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %s -verify
+// expected-no-diagnostics
 module;
 #include "Inputs/h2.h"
 export module use;
 import X;
 void printX(CPP *cpp) {
-  cpp->print(); // expected-error {{'CPP' must be defined before it is used}}
-                // expected-error@-1 {{'CPP' must be defined before it is used}}
-                // expected-error@-2 {{no member named 'print' in 'CPP'}}
-                // expected-note@Inputs/CPP.cppm:5 {{definition here is not reachable}}
-                // expected-note@Inputs/CPP.cppm:5 {{definition here is not reachable}}
+  cpp->print();
 }

clang/test/CXX/modules-ts/basic/basic.link/p2/other.cpp

 // RUN: %clang_cc1 -std=c++1z -fmodules-ts %S/module.cppm -emit-module-interface -o %t
 // RUN: %clang_cc1 -std=c++1z -fmodules-ts -fmodule-file=%t %s -verify
 import M;
 
 void use_from_module_impl() {
   external_linkage_fn();
-  module_linkage_fn(); // expected-error {{undeclared identifier}}
-  internal_linkage_fn(); // expected-error {{undeclared identifier}}
+  module_linkage_fn();   // expected-error {{declaration of 'module_linkage_fn' must be imported}}
+  internal_linkage_fn(); // expected-error {{declaration of 'internal_linkage_fn' must be imported}}
   (void)external_linkage_class{};
   (void)module_linkage_class{}; // expected-error {{undeclared identifier}} expected-error 0+{{}}
   (void)internal_linkage_class{}; // expected-error {{undeclared identifier}} expected-error 0+{{}}
-  // [e-mail]:9 {{here}}
+  // [e-mail]:10 {{declaration here is not visible}}
+  // [e-mail]:11 {{declaration here is not visible}}
   (void)external_linkage_var;
   (void)module_linkage_var; // expected-error {{undeclared identifier}}
   (void)internal_linkage_var; // expected-error {{undeclared identifier}}
 }

clang/test/Modules/Reachability-Private.cpp

+// Tests that the definition in private module fragment is not reachable to its users.
+//
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/Private.cppm -emit-module-interface -o %t/Private.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -verify -fsyntax-only
+
+//--- Private.cppm
+export module Private;
+inline void fn_m(); // OK, module-linkage inline function
+static void fn_s();
+export struct X;
+
+export void g(X *x) {
+  fn_s(); // OK, call to static function in same translation unit
+  fn_m(); // OK, call to module-linkage inline function
+}
+export X *factory(); // OK
+
+module :private;
+struct X {}; // definition not reachable from importers of A
+X *factory() {
+  return new X();
+}
+void fn_m() {}
+void fn_s() {}
+
+//--- Use.cpp
+import Private;
+void foo() {
+  X x; // expected-error {{definition of 'X' must be imported from module 'Private.<private>' before it is required}}
+       // expected-error@-1 {{definition of 'X' must be imported from module 'Private.<private>' before it is required}}
+       // expected-note@* {{definition here is not reachable}}
+       // expected-note@* {{definition here is not reachable}}
+  auto _ = factory();
+  auto *__ = factory();
+  X *___ = factory();
+
+  g(__);
+  g(___);
+  g(factory());
+}

clang/test/Modules/Reachability-func-default-arg.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/func_default_arg.cppm -emit-module-interface -o %t/func_default_arg.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -verify -fsyntax-only
+//
+//--- func_default_arg.cppm
+export module func_default_arg;
+struct t {};
+export t foo(t t1 = t()) {
+  return t1;
+}
+
+//--- Use.cpp
+// expected-no-diagnostics
+import func_default_arg;
+void bar() {
+  auto ret = foo();
+}

clang/test/Modules/Reachability-func-ret.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/func_ret.cppm -emit-module-interface -o %t/func_ret.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -verify -fsyntax-only
+//
+//--- func_ret.cppm
+export module func_ret;
+struct t {};
+export t foo() {
+  return t{};
+}
+
+//--- Use.cpp
+// expected-no-diagnostics
+import func_ret;
+void bar() {
+  auto ret = foo();
+}

clang/test/Modules/Reachability-template-default-arg.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/template_default_arg.cppm -emit-module-interface -o %t/template_default_arg.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -fsyntax-only -verify
+//
+//--- template_default_arg.cppm
+export module template_default_arg;
+struct t {};
+
+export template <typename T = t>
+struct A {
+  T a;
+};
+
+//--- Use.cpp
+import template_default_arg;
+void bar() {
+  A<> a0;
+  A<t> a1; // expected-error {{declaration of 't' must be imported from module 'template_default_arg' before it is required}}
+           // expected-note@* {{declaration here is not visible}}
+}

clang/test/Modules/Reachability-template-instantiation.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/Templ.cppm -emit-module-interface -o %t/Templ.pcm
+// RUN: %clang_cc1 -std=c++20 %t/Use.cppm -fprebuilt-module-path=%t -emit-module-interface -o %t/Use.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t -I%t %t/Use.cpp -verify -fsyntax-only
+//
+//--- Templ.h
+#ifndef TEMPL_H
+#define TEMPL_H
+template <class T>
+class Wrapper {
+public:
+  T value;
+};
+#endif
+
+//--- Templ.cppm
+export module Templ;
+export template <class T>
+class Wrapper2 {
+public:
+  T value;
+};
+
+//--- Use.cppm
+module;
+#include "Templ.h"
+export module Use;
+import Templ;
+
+export template <class T>
+class Use {
+public:
+  Wrapper<T> value;
+  Wrapper2<T> value2;
+};
+
+export template <class T>
+Wrapper<T> wrapper;
+
+//--- Use.cpp
+// expected-no-diagnostics
+module;
+#include "Templ.h"
+export module User;
+
+export template <class T>
+class User {
+public:
+  Wrapper<T> value;
+};

clang/test/Modules/Reachability-using-templates.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/mod.templates.cppm -emit-module-interface -o %t/mod.templates.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -fsyntax-only -verify
+//
+//--- mod.templates.cppm
+export module mod.templates;
+template <class> struct t {};
+export template <class T> using u = t<T>;
+
+//--- Use.cpp
+// expected-no-diagnostics
+import mod.templates;
+void foo() {
+  u<int> v{};
+}

clang/test/Modules/Reachability-using.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/mod.cppm -emit-module-interface -o %t/mod.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -fsyntax-only -verify
+//
+//--- mod.cppm
+export module mod;
+struct t {};
+export using u = t;
+
+//--- Use.cpp
+// expected-no-diagnostics
+import mod;
+void foo() {
+  u v{};
+}

clang/test/Modules/cxx20-10-1-ex2.cpp

 //--- std10-1-ex2-tu5.cpp
 module B;   // implicitly imports B
 int &c = n; // OK
 // expected-no-diagnostics
 
 //--- std10-1-ex2-tu6.cpp
 import B;
 // error, n is module-local and this is not a module.
-int &c = n; // expected-error {{use of undeclared identifier}}
+int &c = n; // expected-error {{declaration of 'n' must be imported}}
+            // expected-note@* {{declaration here is not visible}}
 
 //--- std10-1-ex2-tu7.cpp
 // expected-no-diagnostics
 module B:X3; // does not implicitly import B
 import :X2; // X2 is an implementation unit import B.
 // According to [module.import]p7:
 //   Additionally, when a module-import-declaration in a module unit of some
 //   module M imports another module unit U of M, it also imports all
 //   translation units imported by non-exported module-import-declarations in
 //   the module unit purview of U.
 //
 // So B is imported in B:X3 due to B:X2 imported B. So n is visible here.
 int &c = n;

clang/test/Modules/derived_class.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/foo.cppm -emit-module-interface -o %t/foo.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -fsyntax-only -verify
+//
+//--- bar.h
+struct bar_base {
+  enum A {
+    a,
+    b,
+    c,
+    d
+  };
+  constexpr static bool value = false;
+  static bool get() { return false; }
+  bool member_value = false;
+  bool get_func() { return false; }
+};
+
+template <typename T>
+struct bar : public bar_base {
+};
+
+//--- foo.cppm
+module;
+#include "bar.h"
+export module foo;
+export template <typename T>
+int foo() {
+  bool a = bar<T>::value;
+  bar<T>::get();
+  bar<T> b;
+  b.member_value = a;
+  bool c = b.get_func();
+  return bar<T>::a;
+}
+
+//--- Use.cpp
+// expected-no-diagnostics
+import foo;
+void test() {
+  foo<int>();
+}

clang/test/Modules/explicitly-specialized-template.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/X.cppm -emit-module-interface -o %t/X.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -fsyntax-only -verify
+//
+//--- foo.h
+#ifndef FOO_H
+#define FOO_H
+template <typename T>
+struct base {};
+
+template <typename T>
+struct foo;
+
+template <typename T>
+struct foo {};
+
+template <>
+struct foo<int> : base<int> {
+  int getInt();
+};
+#endif // FOO_H
+
+//--- X.cppm
+module;
+#include "foo.h"
+export module X;
+export template <class T>
+class X {
+  foo<int> x;
+
+public:
+  int print() {
+    return x.getInt();
+  }
+};
+
+//--- Use.cpp
+import X;
+foo<int> f; // expected-error {{'foo' must be declared before it is used}}
+            // expected-note@* {{declaration here is not visible}}
+int bar() {
+  X<int> x;
+  return x.print();
+}

clang/test/Modules/module-private.cpp

int test_broken() {
   Integer i; // expected-error{{unknown type name 'Integer'}}
 
   int *ip = 0;
   f1(ip); // expected-error{{use of undeclared identifier 'f1'}}
 
   vector<int> vec; // expected-error{{no template named 'vector'}}
 
   VisibleStruct vs;
-  vs.field = 0; // expected-error{{no member named 'field' in 'VisibleStruct'}}
-  vs.setField(1); // expected-error{{no member named 'setField' in 'VisibleStruct'}}
+  vs.field = 0;
+  vs.setField(1);
 
   return hidden_var; // expected-error{{use of undeclared identifier 'hidden_var'}}
 }
 
 // Check for private redeclarations of public entities.
 template<typename T>
 class public_class_template;
 

clang/test/Modules/template-function-specialization.cpp

+// RUN: rm -fr %t
+// RUN: mkdir %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/foo.cppm -o %t/foo.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -verify -fsyntax-only
+//
+//--- foo.cppm
+module;
+# 3 __FILE__ 1 // use the next physical line number here (and below)
+template <typename T>
+void foo() {
+}
+
+template <>
+void foo<int>() {
+}
+
+template <typename T>
+void foo2() {
+}
+
+template <>
+void foo2<int>() {
+}
+
+template <typename T>
+void foo3() {
+}
+
+template <>
+void foo3<int>();
+
+export module foo;
+export using ::foo;
+export using ::foo3;
+
+export template <typename T>
+void foo4() {
+}
+
+export template <>
+void foo4<int>() {
+}
+
+//--- Use.cpp
+import foo;
+void use() {
+  foo<short>();
+  foo<int>();
+  foo2<short>(); // expected-error {{missing '#include'; 'foo2' must be declared before it is used}}
+                 // expected-note@* {{declaration here is not visible}}
+  foo2<int>();   // expected-error {{missing '#include'; 'foo2' must be declared before it is used}}
+                 // expected-note@* {{declaration here is not visible}}
+  foo3<short>();
+  foo3<int>();
+
+  foo4<short>();
+  foo4<int>();
+}

clang/test/Modules/template_default_argument.cpp

+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+//
+// RUN: %clang_cc1 -std=c++20 %t/B.cppm -emit-module-interface -o %t/B.pcm
+// RUN: %clang_cc1 -std=c++20 -fprebuilt-module-path=%t %t/Use.cpp -fsyntax-only -verify
+//
+//--- templ.h
+template <typename T, typename U = T>
+class templ {};
+template <typename T, typename U = void>
+void templ_func() {}
+
+//--- B.cppm
+module;
+#include "templ.h"
+export module B;
+export template <typename G>
+templ<G> bar() {
+  templ_func<G>();
+  return {};
+}
+
+//--- Use.cpp
+// expected-no-diagnostics
+import B;
+auto foo() {
+  return bar<int>();
+}